Backend engineering / Microservices
Microservices development.
Boundaries, contracts and operations.
Evaluate a modular application, selected service extraction or a distributed system from actual domain, release and load needs. Plan data ownership, communication, failure recovery and receiving-team operation before adding infrastructure.
Discuss Microservices requirements βContents Β· Microservices
Start with the constraint, not a service-count target.
Microservices work can include domain discovery, extracting a capability from an existing application, service APIs and events, data migration, deployment and operational handover. Establish which business or operating problem a boundary should solve: independent change, different scaling, ownership, isolation or integration.
Plan handlers, domain rules and data access within each service, with versioned contracts, containers, observation and deliberate release control. Inspect the existing application's boundaries before extracting services. Reuse, independent deployment and data ownership need evidence in the actual architecture.
Compare retaining a modular monolith, extracting selected services and a broader distributed design. A service split adds network and data-failure boundaries. No universal team-size threshold, service count, lower cost, faster delivery or unlimited scalability follows from the label.
Handover covers services and the system between them.
Specify source/history and dependency locks for each service, API and event schemas, ownership maps, database migrations, configuration templates, tests, image artefacts, infrastructure or Helm definitions where used, CI, dashboards, runbooks and restore procedures. The receiving team should demonstrate operation, not only receive repositories.
Separate custom IP assignment from framework, shared platform, package, chart, template, asset and provider licenses. Put branding, confidentiality, reuse, support, exit help and account ownership in writing. Transfer production access securely and remove obsolete access; do not include secrets in public manifests or shared handover material.
A managed cluster still needs workload, networking, access, update, data and incident owners. Code and charts alone cannot guarantee independent maintenance or unrestricted rights.
Compare actual change and failure boundaries.
- Modular monolith:one deployable application can have explicit internal modules and data ownership. In-process calls and a shared release can simplify some coordination, but do not guarantee low cost, easy rollback or unlimited headroom.
- Microservices:separate deployables can support selected ownership and scaling needs. That requires compatible contracts, data rules and operational work; splitting processes does not automatically isolate failures or eliminate shared releases.
- Serverless:managed functions or containers can suit selected events or variable workloads. Scaling to zero, cold starts, billing and local tooling vary by product, configuration and workload. They are not universal properties of all serverless systems.
A modular monolith can scale through application replicas, query work, caches and workers when the state and dependencies permit it. A distributed system can still bottleneck on one database or provider. Compare current evidence and lifetime responsibilities, not a generic highest/lowest-cost table.
Seven buyer decisions before a service split.
Should a new product split?
Start from domain clarity, release ownership, load and operations. Compare a modular application rather than assuming a pre-launch product always needs many services.
How can a monolith change gradually?
Evaluate a strangler routing layer and one capability at a time, with explicit write ownership and data reconciliation.
Where should boundaries and data go?
Use business capabilities and actual change paths, then define contracts and ownership. Technical layers alone may not match domain boundaries.
REST, RPC or events?
Distinguish immediate answers from asynchronous facts and workflows. Define deadlines, delivery, duplicates and ordering.
What observation is needed?
Connect metrics, structured logs, traces, queue lag and actionable alerts to business and service objectives.
Is Kubernetes necessary?
Compare a managed container service, current hosts and Kubernetes on actual scheduling, networking, scaling, security and team needs.
What should a candidate demonstrate?
Inspect a real boundary decision, data move, contract test, failure drill, release, restore and handover. Name architecture, data, platform and incident owners.
Domain ownership is more than separate repositories.
Ordering, catalogue, payment and identity are possible capabilities, not a mandatory universal service map. Within each service, handlers, domain rules and persistence can be separated deliberately. A new feature may legitimately cross boundaries; repeated coordinated changes are a diagnostic to investigate, not proof every joint release is wrong.
Define each authoritative data owner and how others obtain permitted information through contracts, events or controlled replicas. A private schema or logical store does not necessarily require a separate physical database server. Conversely, separate servers do not prevent accidental shared-write ownership or contract coupling.
Map synchronous dependencies, libraries, schemas, credentials, shared infrastructure and release sequencing. Services are independently deployable only within their compatibility and data constraints. Multiple repositories or containers do not establish that property by themselves.
The Deployment sample is not a complete service release.
The example apps/v1 Deployment names order-service, selects matching app labels and requests three replicas. Its RollingUpdate sets maxUnavailable:0 and maxSurge:1. The container references registry.example.com/order-service:1.4.2, exposes port 8080 in its specification, reads an existing Secret through envFrom, requests CPU and memory and sets a memory limit.
- The rollout settings guide Deployment replacement behaviour. They do not guarantee zero downtime or full effective capacity during node failure, false-positive readiness, slow draining, database changes, network failure or application errors. Terminating Pods can consume extra resources beyond the surge count.
- containerPort declares container metadata; the sample includes no Service, ingress, external routing, TLS configuration or access policy. It does not establish how a customer reaches the service.
- The referenced image and Secret are placeholders or prerequisites, not deployed artefacts. A mutable tag is not an immutable release identity. Verify image digest, registry access, architecture, provenance and vulnerability/patch decisions.
- The /ready probe runs on its configured period, while /healthz has an initial delay. Their actual handlers are absent. Readiness affects eligible Service endpoints; liveness can restart the container. A startup probe is not shown and the two other probes do not automatically wait for one another.
- Resource requests inform scheduling; limits and actual memory use can cause termination or unschedulable work. These quantities are not throughput guarantees. An HPA, metrics source, scaling target and load evidence are not present.
- No placement, disruption budget, graceful shutdown, database migration, persistent storage, network policy, workload identity or security context is shown. Each may matter in the actual workload, but none is supplied by replicas:3.
- envFrom references Secret data for the process environment. Base64 is not encryption; Kubernetes documentation describes unencrypted etcd storage by default unless configured otherwise. Inspect provider settings, encryption, RBAC, container access and rotation. Existing process environment values do not automatically refresh on a Secret change.
The code preserves the recorded fields while qualifying its original zero-downtime comment. It is an illustrative manifest, not an installed backend, complete production topology or reliability demonstration.
Technical example
Source sample, not an installed backend or verified deployment. The limitations above apply.
# order-service: illustrative rolling update, not a zero-downtime guarantee
apiVersion: apps/v1
kind: Deployment
metadata:
name: order-service
labels:
app: order-service
spec:
replicas: 3
strategy:
type: RollingUpdate
rollingUpdate:
maxUnavailable: 0
maxSurge: 1
selector:
matchLabels:
app: order-service
template:
metadata:
labels:
app: order-service
spec:
containers:
- name: order-service
image: registry.example.com/order-service:1.4.2
ports:
- containerPort: 8080
envFrom:
- secretRef:
name: order-service-secrets
resources:
requests: { cpu: 250m, memory: 256Mi }
limits: { memory: 512Mi }
readinessProbe:
httpGet: { path: /ready, port: 8080 }
periodSeconds: 5
livenessProbe:
httpGet: { path: /healthz, port: 8080 }
initialDelaySeconds: 10Make ownership, replicas and reconciliation explicit.
Document who may write each record, how invariants are checked, and how other capabilities read selected data. APIs and events can protect boundaries only when permissions, schemas and operating rules are enforced. Shared physical infrastructure can be deliberate; uncontrolled cross-service writes undermine ownership even on separate clusters.
Local replicas, materialized views or CQRS-style read models can support selected queries, but introduce freshness, rebuild, schema evolution and reconciliation needs. Event sourcing is a separate design choice, not a requirement for every event-driven system or service.
For money, inventory and entitlements, specify constraints, concurrency and the authoritative state. Do not label all cross-service operations immediately consistent or treat eventual consistency as permission to lose effects. Define user-visible pending states and operational repair.
Sagas compensate business actions, not history.
A saga coordinates local transactions through orchestration or choreography. If later work fails, compensating actions may release stock, cancel a reservation or request a refund. These actions are not an automatic ACID rollback across services and may not perfectly restore the original world.
Define retries, idempotent steps, timeouts, state persistence, concurrent workflows and compensations that can themselves fail. A saga does not provide transaction isolation by default. Pending compensation, irreversible effects and uncertain outcomes may need manual reconciliation and clear customer communication.
An orchestrator needs durable state, availability, versioning and observability. Choreography avoids one central coordinator in some designs but adds event-flow and dependency reasoning. Choose from the workflow rather than claiming one approach always prevents a single point of failure or data inconsistency.
An outbox closes one local dual-write gap.
A transactional outbox records the business change and intended event in the same supported local database transaction. A relay or CDC process then publishes committed changes. This avoids selected database-versus-message dual-write failures; it does not make all downstream consumers part of that transaction.
Relays and brokers can redeliver. Make consumers duplicate-safe using appropriate message identities and durable processing records or business constraints, coordinated with the business change. Define ordering by the relevant entity or partition, schema compatibility, retention, replay and poison-message handling.
CDC emits chosen data changes; interpreting those as meaningful business events requires mapping, ownership and migration rules. A log position is not automatically a customer-visible event contract. Test relay crashes, ack loss, duplicates, out-of-order delivery, backlog and repair rather than promising exactly-once end-to-end effects.
Kafka and RabbitMQ have different delivery, ordering, storage and consumer controls. Select and configure the actual transport; a broker name alone does not establish durability, isolation or safe retries.
Separate immediate answers from asynchronous facts.
Public clients may use REST/OpenAPI or a graph where appropriate, while services use HTTP, gRPC or events. Keep synchronous dependency chains intentional, with deadlines propagated to the relevant work and fallbacks that do not invent success. A timeout at a caller does not prove remote work stopped.
Set bounded retries, budgets, jitter, concurrency and circuit breakers for the actual failure modes. Repeating a payment, message or inventory command requires idempotency and reconciliation. Multiple retrying layers can amplify overload; a circuit breaker is not a substitute for correct state handling.
Version requests, responses and event schemas against actual consumer compatibility. Avoid leaking internal database layouts as permanent external contracts. A shared schema repository can help coordination but cannot prove all deployed consumers are compatible.
A service mesh needs deliberate policy and coverage.
Istio and Envoy can support workload identity, mutual TLS, traffic routing, timeouts, retries and telemetry. Actual behaviour depends on installation mode, enrolled workloads, ports, policy and versions. The security guidance documents permissive configurations that accept plaintext as well as mTLS; naming Istio does not establish strict encryption everywhere.
Configure and test strict transport policy where required, traffic entry and exit, certificate trust, service identity and authorization. A validated workload identity is not business permission for a tenant, order or payment. Keep record and workflow policy in the paths that understand those rules.
Istio request authentication can validate a presented token without necessarily rejecting a missing token unless authorization requires one. Examine actual policy combinations and bypass paths. Proxy and application path interpretation can differ, so test normalization and the precise route semantics.
Timeouts, retries and traffic metrics are not a guarantee of safe recovery without application design. Trace propagation across application calls still needs instrumentation or forwarding; the sidecar cannot infer every inbound-to-outbound causal relationship.
Connect service symptoms to business outcomes.
Use OpenTelemetry or compatible instrumentation for selected traces, metrics and structured logs across HTTP, RPC and messaging. Propagate context deliberately, including asynchronous handoffs, and decide sampling, exporters, collection, retention and access. A service mesh can emit spans but does not automatically stitch every complete request.
- Request rate, errors and duration by relevant service and endpoint.
- Queue or topic lag, age of oldest work, consumer failures and poison work.
- Resource saturation, pool wait, dependency health and throttling.
- Business pending/failed states, reconciliation backlog and duplicate suppression.
- Service/dependency maps, useful trace and log correlation and privacy-aware identifiers.
- Alerts tied to agreed service or business objectives, with incident owners and response procedures.
Traces are useful evidence, not the only possible debugging tool. Avoid credentials and sensitive payloads in headers, baggage, labels and logs. High-cardinality labels and unlimited telemetry retention have cost and privacy consequences. A dashboard does not prove someone is responding.
Images, probes and capacity are different controls.
Build reviewed release images with chosen runtime, dependency locks, patching and configuration. A smaller image may improve transfer or reduce selected contents but is not a universal security or performance guarantee. Test the actual release artefact and its startup and shutdown behaviour.
Choose CPU/memory requests and limits from measurements and scheduling constraints. HPA is a separate controller and configuration, using an available metrics source and chosen targets. Resource utilization can depend on requests; scaling is periodic and cannot guarantee immediate extra capacity or fix a saturated database.
Use readiness for traffic eligibility, liveness for appropriate restart detection and startup probes where needed. Do not restart every service simply because a shared dependency is temporarily down. Test slow startup, loss of dependency, overload, termination and endpoint draining on representative infrastructure.
Queue workers can isolate heavy reports or media processing from request handlers, but still need bounded concurrency, durable work, duplicate-safe effects, retries and separate scaling evidence. A fast API acknowledgement is not completed work.
Kubernetes is a choice with ongoing responsibilities.
Compare existing hosts, managed container services and Kubernetes on workload scheduling, routing, autoscaling, storage, policy, deployment and team needs. EKS, GKE or AKS may manage control-plane functions, not every workload or incident. ECS and Cloud Run have their own contracts and operating limits; no universal cheaper service-count threshold is adopted.
For Kubernetes, specify cluster and namespace access, workload identity, network policy, secret storage, registry access, node/zone placement, quotas, update/patch ownership, backups and recovery. An HPA or disruption budget is not a guarantee against every node or regional failure.
Verify cloud and provider charges, idle capacity, load balancers, storage, data transfer and telemetry. Several services can share an owning team when responsibility and capacity are explicit; neither a fixed engineer-to-service ratio nor one mandatory platform is established by the source.
Identity, secrets and domain policy span every path.
Inventory external and internal endpoints, service identities, user/tenant context, object and field rules, batch/event paths and administrative access. Require least privilege at network, workload, database and business layers. Internal network location or mTLS is not a blanket authorization grant.
Keep secrets out of images, source, public manifests, logs and event payloads. Configure appropriate encryption at rest, least-privilege RBAC and workload access, rotation and incident response. An environment variable or Secret reference alone does not establish encrypted storage or safe credential lifecycle.
Test forged headers, missing or wrong-audience tokens, replay, cross-tenant reads, unauthorized commands, workflow reordering and duplicate callbacks. Apply validation, output controls, rate and resource limits and secure provider verification. A package scan or mesh policy is bounded evidence, not a compliance certificate.
Specialist obligations for patient, financial or location data need deliberate review. Record retention, residency, audit, access and deletion responsibilities, rather than claiming a technology automatically supplies GDPR, SOC 2 or banking approval.
Release compatibility, data and traffic together.
Coordinate API/event compatibility, migrations, artefacts, configuration and routing across rolling, canary or other chosen release methods. Readiness success is not proof a new version handles real authorized traffic correctly. Use relevant smoke tests and service/business indicators.
Kubernetes can report a stalled Deployment; the Deployment controller does not automatically roll it back simply because the progress deadline is exceeded. Define the release system and human fallback that evaluates the state and acts. A previous image may be incompatible with a new database or event schema.
Test graceful shutdown, in-flight requests, queue processing, traffic draining, backups and restore. Separate binary rollback from data repair and external-effect reconciliation. A refund or sent notification cannot be undone by restarting an older container.
For multiple zones or regions, specify data and event consistency, failover triggers, identity/configuration distribution, stale reads, provider dependencies and recovery drills. Three replicas and a maxUnavailable setting are not a regional availability promise.
Three engagement models have separate acceptance.
Adapt a product base
Inspect whether the actual reusable platform has appropriate services, contracts and rights. Define branding, configuration, custom gaps, data move and receiver needs without assuming a catalogue card proves a microservices architecture.
Build or extract selected services
Agree boundaries, contracts, ownership, event/workflow semantics, deployment and observations, with reviewed acceptance for the chosen capability. A mobile-widget diagram in source copy is not backend architecture evidence.
Continue a distributed system
Scope service changes, schema compatibility, platform upgrades, operations, incidents, runbooks and exit help. Confirm actual staffing and current support terms rather than inheriting a retainer or availability claim.
No fixed price, guaranteed build interval, included support period or cancellation notice is adopted as a current offer.
Six quality areas with failure evidence to inspect.
- Architecture and contract review:boundaries, authoritative data, dependency paths and consumer compatibility.
- Unit and static checks:domain transitions, adapters, serializers and selected processing rules.
- Integration and end-to-end:service, broker, data and provider paths, with forbidden actions and partial failures.
- Performance:release images, real workloads, pools, queues, autoscaling, saturation and recovery.
- Security:identity, domain permissions, secret lifecycle, network/mesh policy and abuse paths.
- Operations:CI permissions, artefacts, migrations, rollout/forward-fix, backup/restore, runbooks and receiver operation.
A coverage percentage, scanner, service map or load test is scoped evidence, not proof every distributed failure has been solved. Record open risks and acceptance conditions.
Sixteen technology groups need specific roles.
- Go/Rust:selected service runtimes, libraries and receiving-team skills.
- Docker/Kubernetes:release artefacts, scheduling, configuration and operating ownership.
- Redis/RabbitMQ:chosen cache or broker role, persistence and recovery.
- Istio:enrollment, traffic, transport identity and authorization policy.
- Kafka:event schemas, partitions, offsets, retention and duplicate handling.
- Maps:provider permissions, quotas, location privacy and stale data.
- Stripe/Razorpay:current provider contracts, callbacks, idempotency and reconciliation.
- WebSocket:live protocol, channel permissions, reconnect and stale-state repair.
- GraphQL/REST:client and service contracts with actual policy.
- PostgreSQL/MongoDB:data model, constraints, consistency and restore.
- GitHub Actions:reviewed build, tests, artefacts and release access.
- Node.js:runtime, dependency and concurrency behaviour.
- REST/webhooks:provider messages, signatures, retries and effect state.
- Sentry:error collection, privacy, alerts and response ownership.
- OpenTelemetry:context propagation, instrumentation, sampling and export.
- Docker/AWS:chosen hosting services, secure configuration and recurring costs.
The source repeats some technologies across cards. Preserve those scope groups without claiming each one is installed or required.
Five stages from discovery through receiver operation.
- Brief:business constraints, current code, consumers, data and risk.
- Scope:boundaries, contracts, state transitions, platform and dependency owners.
- Build:reviewed services, data changes, integrations and demonstrable increments.
- QA:contract, security, load, failure, migration and recovery evidence.
- Handoff:approved release, accounts, runbooks, observations and receiving-team demonstration.
Agree milestones after discovery and record external approvals, client migrations and operating dependencies. No first-commit, NDA-turnaround, custom-build or launch interval from the source is adopted as a promise. Mobile-store work is separate where the wider product includes apps.
Quote coordination and operation as well as code.
Get current itemised terms for product adaptation, selected extraction, custom work or ongoing support. Historical starting prices, MVP ranges, retainer figures, fixed delivery windows and free support are not current offers.
- Boundary discovery, service contracts, data ownership and compatibility work.
- Migration/backfills, dual-running, source changes and reconciliation.
- Sagas, events, idempotency, provider and ledger effects.
- Build/release pipelines, platform, network/security and secret lifecycle.
- Testing, telemetry, incident coverage, backups, recovery and receiver training.
Cloud compute, databases, broker storage, traffic, monitoring and licenses can create recurring costs. Compare actual workloads, managed-service options and team responsibility; neither microservices nor a monolith has one universal cost ranking. A free testing deployment is not production capacity or a commercial launch.
A routing flag is not a complete data rollback.
Inventory the monolith, consumers, domains, write paths, shared tables, libraries and external effects. A routing layer can direct one capability to new code while other paths remain on the old application. Select an extraction based on actual coupling and risk, not a universal rule that payments or notifications must come first.
An anti-corruption layer can map contracts; CDC and backfills can support data movement. Define authoritative writes, transformation, conflict policy, lag, reconciliation and deletion. Dual writes or bidirectional changes need explicit failure handling, not an assumption both stores stay synchronized.
Shadow comparisons must avoid duplicate charges, messages and other side effects. Use controlled traffic and consumer tests, observe real state, then retire old paths only after ownership and data checks. Feature flags can change routing, but new writes may prevent a simple route-back rollback.
Record reversible steps, forward-fix and repair, backup restoration and the receiving teamβs cutover procedure. No zero-downtime, zero-data-loss or no-rewrite outcome is established by naming the strangler pattern.
The Tokyo story is a requirements example, not results proof.
An ecommerce monolith review can examine peak food or order load, catalogue, ordering and payment boundaries, selected service extraction and ongoing client compatibility. Evaluate Go or Node.js services, Kubernetes, Istio, Kafka, Redis and PostgreSQL only where workload and operating needs justify them, with explicit load, migration and runbook work.
Its opening narrative gives one duration, the explicitly illustrative project brief uses another target and the outcome narrative gives a third. Those are not reconciled evidence of one completed engagement. Preserve the scope and request a written plan instead of choosing a duration or claiming delivery.
Capacity, error reduction, funding, customer satisfaction, compliance and no-downtime outcomes are unverified. No named customer, actual production deployment or measured before/after result is asserted here. A production-like test plan still needs actual workload, methodology, artefacts and findings.
Microservices delivery review and handover.
The acceptance review can cover one boundary decision and its tradeoffs, actual service/data ownership, a consumer-contract failure, a duplicate event, an outbox relay crash, failed compensation, cross-tenant denial, a bad rollout and a restored backup. Request complete artifacts and operating evidence, not only a cluster screenshot.
Product patterns to consider include utility billing with metering, dunning, tax rules, customer portals and tenant reporting; security dashboards with collectors, alerts, scoring and playbooks; and B2B commerce with orders, payments, credit, distributor pricing and reconciliation. Define the exact records, permissions, integrations and failure states for the selected product. These are possible project scopes, not a client portfolio.
The written scope should name the selected implementation, source and third-party rights, account ownership, release responsibilities and support terms. Include a receiving-owner walkthrough of the agreed build, tests and recovery steps, with open items recorded before acceptance.
Eight sectors become explicit system requirements.
- Healthcare/life sciences:patient and appointment access, audit, retention and specialist privacy review.
- Telemedicine:participant permissions, consultation state, scheduling and secure messages.
- Fintech:ledger and payment boundaries, KYC providers, uncertain effects and reconciliation.
- Retail/eCommerce:catalogue, stock, checkout concurrency, fulfilment and refunds.
- Media/entertainment:content rights, entitlements, subscriptions and playback access.
- Creator economy:payouts, paywalls, usage, moderation and analytics.
- Transportation/mobility:dispatch, location freshness, cancellations and settlement.
- Food/beverage:menu, kitchen, order and courier state, prices and refunds.
Twelve questions before microservices work starts.
What does microservices work include?
Agree domain boundaries, contracts, data, communication, platform, tests and receiver needs.
What does it cost?
Get itemised build and operating scope, including migration, telemetry and incident responsibility.
How long does it take?
Inspect coupling, data and dependencies before agreeing milestones. Sequence extraction, client changes, data migration and operating handover against the actual application.
Can a reusable platform help?
Inspect actual topology, features and rights, then scope custom gaps and acceptance.
Which tools are used?
Choose runtimes, database, broker, platform, identity and observation from the actual system.
Should a new product use services?
Compare a modular application and selected extraction against domain, release, load and team needs.
Can a monolith change gradually?
Yes where boundaries, routing and data movement permit it, with controlled effects and reconciliation.
Is Kubernetes required?
No universal rule applies; compare actual managed services, current infrastructure and operating capability.
What support follows release?
Agree versions, incidents, access, costs, documentation and exit help in writing.
Can remote teams coordinate?
Confirm identity, communication, language, time-zone overlap and availability rather than inheriting office or hours claims.
Is the source ours?
Separate custom assignment from base, framework, package, asset and provider rights, then test handover.
How are services secured and scaled?
Enforce identity and domain permission, resource and failure controls, measured capacity and recovery; a mesh or HPA is not a guarantee.
Primary references for technical qualification.
Official platform, framework and API documentation checked on 17 November 2026. These support the technical checks here, not Omnistu staffing, pricing, rights, delivery or client outcomes. Recheck installed versions and configuration before implementation.
- Deployments | Kubernetes - kubernetes.io
- Configure Liveness, Readiness and Startup Probes | Kubernetes - kubernetes.io
- Secrets | Kubernetes - kubernetes.io
- Horizontal Pod Autoscaling | Kubernetes - kubernetes.io
- Pod Lifecycle | Kubernetes - kubernetes.io
- Istio / Security - istio.io
- Istio / Traffic Management - istio.io
- Context propagation | OpenTelemetry - opentelemetry.io
- Transactional outbox pattern - AWS Prescriptive Guidance - docs.aws.amazon.com
- Saga orchestration pattern - AWS Prescriptive Guidance - docs.aws.amazon.com
- Istio / Security Best Practices - istio.io
- Istio / Distributed Tracing FAQ - istio.io
- Istio / Understanding TLS Configuration - istio.io
- Strangler fig pattern - AWS Prescriptive Guidance - docs.aws.amazon.com
- Idempotent consumer pattern
- Saga coordination and outbox
- Kubernetes environment variables
- Updating process environment configuration
Bring the domain, dependencies and receiving-team needs.
Describe the records, users, permitted actions, integrations, existing code and operating constraints. Agree base/custom boundaries, acceptance evidence, current quote and handover before implementation.
Discuss Microservices requirements β