Playbook menu
TechSoft Delivery Playbook
One team. Clear responsibilities. Reliable software.
We combine experienced engineers, AI-powered workflows and rigorous quality controls to help businesses build, modernize and operate software with confidence.
Overview: how we deliver software
The playbook is our written description of how a TechSoft team takes a client's problem to reliable, working software: the stages, the roles, the rules and the weekly rhythm. We publish it so you can judge how we work before you hire us.
The problems it addresses
- Software that takes too long to ship, or ships with too many surprises.
- Old systems that are costly and risky to change.
- AI tools adopted without clear rules for quality, security or ownership.
- Paying for hours instead of getting a result you can measure.
How AI changes our delivery
AI helps us draft code, tests and documentation, understand old code and investigate defects. That makes writing code cheaper. It does not make it safe or right. What a client should pay for is judgment, discipline and accountability, so that is what we put around the tools.
Why people stay accountable
An AI cannot be held to account. Every change is understood and owned by an engineer, and architecture, security exceptions and releases are approved by named people.
What you can expect
- The same five stages, with a clear milestone at each.
- Working software in short, regular increments.
- One backlog, a weekly status and an honest risk list.
- Progress measured against a baseline we agree with you.
Built on four values
#Kindness
We treat people the way we want to be treated. We are honest and open, we respect one another, and we support and encourage each other, in the team and with our clients.
#Sustainability
We think long term. We look after our health, keep learning and growing, and share what we know with our team and the wider community.
#One-Team
We share goals and succeed together. Everyone takes ownership of their work, looks for practical ways to move forward, and celebrates results as a team, including our clients.
#Excellence
We care about quality and stand behind our work. We hold ourselves accountable and aim to get a little better every day.
The delivery lifecycle
Every engagement moves through five stages, scaled to its size. For each one you can see what happens, what you receive, which quality checks apply and what must be approved before we move on.
= milestone agreed with the client
01
Discover
Problem and baseline
02
Design
Architecture and scope
03
Build with AI
Reviewed increments
04
Verify
Gates and acceptance
05
Operate & improve
Monitor and learn
STAGE 01
Discover
Understand the business problem, set the baseline and success measures, and surface constraints and risks.
You receive
- Problem statement and success measures
- Current-state map
- Risk register
Quality checks
- Problem statement and success measures read back to the client
- Baseline numbers recorded, not estimated
Approved before we move on
The Client Sponsor agrees the problem statement, success measures and next step.
STAGE 02
Design
Define requirements and acceptance criteria, weigh the technical options, and plan the delivery.
You receive
- Architecture and ADRs
- Backlog and roadmap
- Prototypes and design specs
Quality checks
- Architecture reviewed by the Tech Lead; key decisions recorded
- Every story has testable acceptance criteria
Approved before we move on
Architecture, scope for the first release and acceptance criteria approved by client and Tech Lead.
STAGE 03
Build with AI
Work in small increments. AI tools and agents help where appropriate; engineers review and own every change.
You receive
- Working increments in a shared environment
- Automated tests
- Updated documentation
Quality checks
- Peer review of every change, including AI-assisted ones
- Automated tests, static analysis and dependency checks in the pipeline
Approved before we move on
Each story meets the definition of done; the increment is demonstrated to the client.
STAGE 04
Verify
Run automated and manual tests, check security, reliability and maintainability, and get the approvals needed to release.
You receive
- Test report and open-defect list
- Security findings and decisions
- Acceptance sign-off
Quality checks
- Regression, integration and performance testing
- Security and dependency checks; findings triaged
Approved before we move on
Release gates passed; the Client Sponsor approves the release.
STAGE 05
Operate and improve
Monitor production, track incidents, defects and performance, and feed what we learn back into the next cycle.
You receive
- Runbooks and dashboards
- Monthly report
- Updated roadmap
Quality checks
- Monitoring and alerts reviewed
- Incidents get a post-incident review
Approved before we move on
Ongoing: priorities and improvements reviewed monthly with the client.
AI engineering, with people in charge
AI supports the whole workflow, from requirements to production incidents. We apply it in three levels, step by step, with defined permissions and human approval.
Level 1 · Where it starts
AI-assisted engineering
Individual engineers use approved AI tools to speed up specific tasks, such as drafting code and tests, explaining unfamiliar code or summarizing requirements. The engineer reviews and owns the result.
Level 2 · Where we are building toward
AI-orchestrated delivery
Controlled AI-agent workflows handle bounded engineering tasks, for example a refactor or a test suite. Each has defined permissions, automated verification and clear rules for when to stop and ask a person.
Level 3 · The longer-term direction
AI-enabled operations
AI helps monitor running systems, diagnose incidents, spot recurring defects and technical debt, and suggest improvements. People decide what changes in production.
These are capabilities and working patterns we apply step by step, agreed with each client. They are not a claim that every capability is already in use on every project.
Who does what
AI
Generates, analyzes, summarizes and recommends
Never approves, accepts or releases anything.
Engineers
Review, validate, understand and own changes
If an engineer cannot explain it, it does not ship.
Automated controls
Test, scan, validate and enforce defined policies
Failing checks block the merge or the release.
Human decision-makers
Approve architecture, security exceptions, releases and consequential production changes
Named people, recorded decisions.
Your code and data
Client code and data
Agreed at kickoff in the engagement's AI-use policy. Only approved tools touch client code or data.
Access control
AI tools and agents get the minimum access they need, on specific repositories and environments, and nothing more.
Secrets and regulated data
Credentials, secrets and regulated data stay out of AI tools unless the policy explicitly allows it.
Auditability
Changes live in version control with the author, the reviewer and the checks that ran. We record when AI assisted a change where the policy requires it.
Human approval
Architecture, security exceptions, releases and consequential production changes are approved by named people.
Tool terms
Each AI tool has its own data-retention and training terms. We check them before approving a tool, and we tell you which tools we use. We do not promise anything beyond what a tool's terms and our controls support.
Quality, security and governance
These controls are what make AI-powered engineering dependable. They reduce risk; they do not promise perfect security or zero defects.
Version control and traceable changes
You can see who changed what, when and why, and go back if something goes wrong.
Automated testing
Mistakes are caught in minutes, not discovered by your users.
Code review
A second pair of human eyes on every change, including AI-assisted ones.
Static analysis and dependency scanning
Common defects and known-vulnerable libraries are flagged before release.
Security review and remediation
Findings are triaged, assigned an owner and tracked until closed or consciously accepted.
Acceptance criteria
Everyone agrees up front what “working” means, so acceptance is not an argument.
Release approval
Nothing reaches production without a named approver.
Rollback and recovery planning
If a release misbehaves, there is a tested way back.
Production monitoring
Problems are seen by us first, with alerts and dashboards.
Decision rights and escalation
Everyone knows who decides what, and how a problem moves up quickly.
Metrics that connect to outcomes
Each measure has a baseline, a measurement period and one agreed definition. These are the measures we propose. Actual results are reported per engagement, and we never use lines of code as a productivity measure.
Delivery
How quickly useful software reaches users.
- Lead time for changes
- Time from a change being started to it running in production
- Time to first usable release
- Time from kickoff to the first release real users can use
- Deployment frequency
- How often we release to production
Quality and reliability
Whether what we ship works and stays working.
- Escaped defects
- Defects found in production that testing should have caught
- Change failure rate
- Share of releases that cause a failure or need a fix or rollback
- Time to restore service
- How long it takes to recover from an incident
- Security findings and remediation
- Findings raised, and how long they take to close
AI effectiveness
Whether AI is really helping, not just producing more code.
- Time saved on selected tasks
- Compared with the same kind of task before AI, on agreed examples
- AI-assisted changes accepted after review
- Share of AI-assisted changes that pass review
- Rework from AI-generated changes
- Fixes and rewrites needed after AI-assisted work
- Verification and review effort
- Time people spend checking AI output
Business outcomes
Whether the software moved something the client cares about.
- Time to market
- Time from idea to clients using it
- Feature adoption
- How many people actually use what we shipped
- Operating cost
- Cost to run and support the software
- Client-defined return on investment
- Measured against the client's own definition of value
Delivery
Faster, smaller releases
Quality and reliability
Fewer failures, faster recovery
AI effectiveness
Time saved, minus the checking it needs
Business outcomes
Time to market, adoption, cost, your own ROI
Three ways to start
You do not need a large commitment to find out whether this works for you.
Path 1
AI Engineering Assessment
A focused look at your architecture, development process, AI readiness, technical debt and quality risks.
Possible deliverables
- Current-state assessment
- Prioritized improvement roadmap
- Recommended pilot scope
- Baseline metrics
Path 2
AI Engineering Pilot
We apply the approach to one bounded feature, workflow or modernization task, so you can judge it on real work.
Possible deliverables
- Working software
- Test and quality evidence
- Documented workflow improvements
- Comparison against an agreed baseline
Path 3
Continuous Product Engineering
We extend what worked into ongoing engineering, modernization, quality and operations.
Possible deliverables
- Prioritized roadmap
- Regular software releases
- Quality and operational reporting
- Continuous improvement recommendations
Scope, timing and commercial terms are agreed with you for each engagement. This page does not set prices or standard durations.
Evidence from real engagements
These engagements are already public on our site. We publish only approved details and results.
IoT (manufacturing, MES software)
From Bottleneck to Breakthrough: Scaling Delivery Without Scaling Headcount
A Dutch manufacturing execution systems provider had more demand than its engineering team could handle. An embedded TechSoft team cleared the backlog and added design, QA and DevOps skills.
Read the case study →
Healthcare: behavioral health and correctional institutions
A Human-Centered Safety And Care Platform for Healthcare and Correctional Environments
TechSoft helped a Netherlands-based MedTech company rebuild a decade-old on-premise platform into a cloud-based SaaS solution on Microsoft Azure, without disrupting the care it supports.
Read the case study →
Healthcare
Technology Empowering The Path To Parenthood
TechSoft built the web and mobile systems of a fertility platform that connects patients and clinic staff across the whole treatment journey.
Read the case study →
Detailed working standards
The reference material our teams work from. Open a group to see its pages. Every page names an owner and the date it was last reviewed, and is reviewed again at least every six months.
Client
- Client Sponsor
- Product owner and technical contacts
- Users and stakeholders
TechSoft delivery team
Leadership
- Delivery Manager
- CTO (security, compliance, AI and data)
Design
- UX/UI Designer
- Requirements work is shared across the whole team
Engineering
- Solution Architect / Tech Lead
- Software Engineers
Quality & operations
- QA / Test Automation
- DevOps / Platform
- Support & Operations
One backlog · one definition of done · one status report
All roles work from the same plan, visible to the client
The client and the team work together every week.
Start here 2 pages
Roles 4 pages
Project leadership and responsibilities
The Client Sponsor, our Delivery Manager and our CTO.
Product and design roles
The UX/UI Designer, and how requirements work without a separate Business Analyst.
Engineering roles
Solution Architect / Tech Lead and Software Engineers.
Quality and operations roles
QA / Test Automation, DevOps / Platform, and Support & Operations. Security and compliance sit with the CTO.
Lifecycle 6 pages
The five-stage lifecycle
Discover, Design, Build, Verify, Operate: how work flows from problem to production and back.
Stage 1: Discover
Agree the problem, the baseline and the desired outcome before committing to a solution.
Stage 2: Design
Define what will be built, how it will be built and how it will be accepted.
Stage 3: Build with AI
Deliver working software in small, reviewed steps. AI helps; people stay responsible for the result.
Stage 4: Verify
Prove that the software works, is secure and can be released.
Stage 5: Operate and improve
Run, measure and keep improving the software after release.
Working agreements 3 pages
Decision rights (RACI)
Who is responsible, accountable, consulted and informed for each key activity.
Cadence and meetings
The rhythm of an engagement: what happens daily, weekly, per sprint and monthly.
Definition of ready and done
The checks at the start and end of a story that keep stories small, clear and truly finished.
Quality & AI 4 pages
Quality gates
Four gates a change passes between idea and production, and what each one checks.
AI engineering
How AI supports the whole engineering workflow, who is responsible for what, and the rules that keep it safe.
Delivery with and without AI
How our development approach differs with AI, stage by stage, and what stays exactly the same.
Measuring our AI speed-up
How we measure whether AI really makes delivery faster, and what we publish with every number.
Craft 3 pages
Code review
What happens between a change being written and being merged, and what a reviewer actually checks.
Testing
The kinds of testing we do, who does each, and how defects are reported and closed.
How an engineer reads AI-written code
The extra care we take with code that an AI tool wrote, and why the engineer stays responsible for it.
Services 1 pages
Governance 2 pages
People and careers 5 pages
How we hire
How candidates are matched, interviewed by practitioners, and assessed against our career levels.
Onboarding a new team member
What happens in the week before someone joins a project, and who is responsible for each step.
Junior and intern path
How people start their careers with us and grow into the graded levels.
Career levels
The grading ladder from fresher to principal, and how expectations build on each other.
Performance and feedback
How the career levels are used to give feedback and recognize growth.
