How I'd lead

Two seats, one job: keep the why, the what and the how together.

“I'm a servant leader: learn by listening, win by collaborating.”
That's the foundation for everything below, whether the team is small or large.

I've led engineering teams and I've owned the architecture, sometimes in the same role. This is how I'd approach each seat, and how I take stock when I join a new team or inherit a platform. It's written from what has worked for me, and from what I've got wrong.

Principles

Five things I hold to in either seat.

  1. 01

    Own it end to end

    One leader accountable for why we're building something, what it should be and how it gets built, so a trade-off is made once, with the whole picture, rather than argued over across three hand-overs.

  2. 02

    Standardise where it helps people move

    Shared patterns, tooling and standards, so engineers can move between teams and designs can be reviewed quickly. Everywhere else, teams choose.

  3. 03

    Build only what makes us different

    Buy or use open source for the rest, and use software-as-a-service for what it's for, without heavy custom building on top.

  4. 04

    Security and data designed in

    Controls, data ownership and audit evidence start in the first design, not in a rush before go-live. In a regulated business they shape every plan.

  5. 05

    Release small and often

    Small changes behind automated quality gates, with a rollback plan for every release. Fixed dates are kept by planning back from them, one small step at a time.

As Head of Engineering

Delivery people can rely on, from teams who want to stay.

An engineering leader is measured by what the teams ship, how well it runs, and how people feel doing it. Most of the job is people and delivery, not design.

My first 90 days

Listen first, shape together, then go. I don't change anything in the first month.

  • Days 1–30, listen and learn: one-to-ones with everyone, skip-levels, and the promises already made to people. Every system in my remit, who knows it best, its SLOs, its audit findings. How work comes in, gets prioritised and reaches production.
  • Days 31–60, immerse and shape: hands-on in the real work, gaps found with peers across the business, and ideas tested with the people who'll live with them. A vision built with the team, not for it.
  • Day 61 on, get set and go: priorities everyone can explain, the measures we hold ourselves to, and early wins that build trust with the business and within the team.

How I run delivery

  • Priorities agreed in the open with business partners, so engineering isn't the place where competing asks collide.
  • Capacity and demand planned honestly, including time set aside to pay down technical debt from a visible register.
  • Small releases behind automated quality gates, such as minimum test coverage on new code, so speed and quality stop being a trade-off.
  • Partners and suppliers held to the same design reviews and coding standards as our own teams. I don't sign off work that wasn't built as designed.

How I build quality in

An error should be caught at the earliest possible stage. Testing, peer review and release are each a chance to catch it, and a defect that reaches customers has slipped past every one. I learned this the hard way early in my career.

  • Tests written alongside the code, peer review before anything merges, and automated gates before anything releases.
  • When something does escape, we ask which stage should have caught it, and keep refining our review and testing practice from that.

What I look for in a peer review

  • The size of the change: small enough to review properly
  • The design patterns it uses
  • The security patterns it follows
  • Where the business logic is written, and whether it's right
  • Whether the change fits the capability it serves

Automation, with people in the loop

  • Automate everything repeatable. Keep people for judgement: the edge cases no test anticipates, and exploring the screens and forms the way a customer would.
  • With AI agents, the agents do the work inside guardrails, and a person approves what reaches production.

How I run operations

  • Reliability targets set by tier: every service mapped to availability and recovery targets, with failover tested on a schedule.
  • Incidents handled calmly, with clear roles, and reviews that look for causes, not culprits.
  • Regulatory and audit deadlines planned from day one, and treated as fixed.
  • Licences and vendors managed like any other part of the platform: renewals, service levels and upgrade plans.

How I look after people

  • Lead through managers with clear decision rights, so decisions don't all route through me.
  • Own the mistakes as the leader, give the credit away, and keep blame out of the room.
  • Make good work visible to the people who decide careers, well before a promotion case.
  • Bring change in step by step, with the team, and measure team health as seriously as delivery.
  • Break down silos by building trust between teams and with the business.

As the team grows

The same principles hold whatever the size. What changes is how I make sure they still reach everyone.

  • Teams aligned to platforms, with spans narrow enough for managers to coach.
  • Managers grown from within, and hiring for the gaps.
  • A steady rhythm: regular one-to-ones, skip-levels and an open door.
  • Real ownership for each team, with dashboards that give visibility without micromanaging.
  • A baseline taken before anything changes.

The numbers I baseline first

Before I change anything, I want to know where we start. Then we track it together.

  • Lead time for changes, deployment frequency and change failure rate
  • Time to restore service, and availability against each tier's targets
  • Escaped defects, and automated test coverage on new code
  • Planned against delivered work, and where work waits longest
  • Team health: attrition, open roles and how people say they feel
  • Run cost: cloud, licences and vendor spend per platform

As Head of Solution Architecture

Architecture that helps teams deliver, not a gate they wait at.

Architecture earns its place when it changes a business decision and makes delivery safer and faster. If a design review is slowing a team down, that's a problem for the architects to fix, not the team.

Design authority

  • A design board any team can call, including at short notice, that reviews the decisions that are expensive to undo.
  • Decisions written down as architecture decision records, with the options considered and the reasons.
  • Standards and delegated approvals, so most designs never need the board at all.
  • Exceptions granted case by case, recorded, and revisited, rather than quietly becoming the norm.

Standards

  • A short set of principles the teams can explain back, and the why behind each one.
  • A pattern catalogue for integration and APIs, with contracts such as OpenAPI and AsyncAPI, and policy as code in the delivery pipeline.
  • Resilience tiers that map each application to availability, latency and recovery targets.
  • Security and data rules built into the patterns, so doing the right thing is the easy thing.

Build or buy

One question first: is this what makes us different?

  • If it is, we build it, and we build it well.
  • If it isn't, we buy it or use open source, and use the product as it was designed, without heavy custom building on top.
  • When rationalising an estate, I make a decision per application (tolerate, invest, migrate or eliminate) and sequence compliance and quick wins first.
  • And I'll stop a move when the evidence says it isn't ready, even late. I once stopped a platform move 120 days before go-live because the gaps it would have left created a compliance risk.

How architecture serves delivery

  • Architects sit with the teams that build, and stay with them until the design lands.
  • Guardrails, not gates: the rules that matter live in code and pipelines, not in approval queues.
  • Ask before answering. The team still gets the benefit of experience, but the design, and the understanding behind it, becomes theirs.
  • Roadmaps tied to investment decisions, so the target architecture is something the business has chosen to fund.

Taking stock of a team or platform

Before I change anything, I want to see it as it really is.

Whether I'm joining a team, inheriting a platform or looking at an estate after a merger, I use the same approach. I've done technical due diligence on deals as a consultant, and after a merger I mapped a combined estate application by application.

What I look at

People

  • How teams are organised, and who decides what
  • Where knowledge sits with one person
  • Promises already made to people, and morale
  • The mix of our own engineers and partners

Platform

  • Every application: its purpose, owner and integrations
  • Targets against how it really performs
  • Incident history, technical debt and unsupported software
  • Open security, audit and regulatory findings
  • Who owns the data, and how good it is

Delivery

  • How work comes in and gets prioritised
  • How it reaches production, and how much is automated
  • What still depends on people and goodwill

Money and partners

  • Run cost: cloud, licences and support
  • Vendor contracts, service levels and renewal dates
  • Whether the platform can carry the load that's coming

The questions I ask

  • “What happens when the volume doubles?”
  • “How do we roll this back if it fails at two in the morning?”
  • “Who else will need this data next year, and how will they get it?”
  • “What would make this hard to change in six months?”
  • “Which promise, to the team or to the business, is most at risk?”
  • “What do the auditors already know that we haven't fixed?”

How I find what to improve

  1. 1Map the estate first: capabilities, applications and a decision for each one.
  2. 2Follow one piece of work from idea to production, and note where it waits.
  3. 3Compare each service's targets with what it really delivers.
  4. 4Rank the gaps by risk and by value. Compliance and safety first, then quick wins, then the longer roadmap.
  5. 5Test the ideas with the people who'll live with them before anything is decided.
“As an architect I was paid to have the answer. As a leader, my job is to make sure the team finds it, and understands why it's right.”
From my article: From architect to engineering leader →Ask for my CV

Contact

Let's talk.

I'm based in London, UK. If you're hiring a Head of Engineering or Head of Solution Architecture for a regulated data, payments or AI platform, I'd be glad to talk.

srini.vankee@gmail.com
↑