ICT-Platform Dev Specialist FA study plan

Map every layer of a reference platform (edge/CDN, gateway, service tier, async workers, data stores, identity provider) into a single annotated diagram you draw from memory at the end of the week

Compare monolithic, layered, microservice, and event-driven styles by listing two concrete trade-offs each for latency, operability, and failure isolation, then justify a style choice for a given workload

Explain synchronous request/response versus asynchronous queue or stream processing with a worked latency and backpressure example for each

Write the non-functional requirements (availability target, p99 latency budget, RPO/RTO) for a sample platform and trace each one to an architectural decision

Decompose a platform into bounded services, defining each service's responsibility, owned data, and public contract in a table

Design the data flow for one cross-service workflow, specifying where transactions end and where eventual consistency with compensation begins

Build a small working service (any mainstream language) exposing two REST endpoints backed by an in-memory store, with input validation and structured logging

Refactor that service to separate transport, business logic, and persistence layers, and confirm behavior is unchanged via tests

Implement the same small feature in a stateless and a stateful style, then document which one survives horizontal scaling and why

Add centralized error handling and idempotency keys to the week-2 service so a retried write does not duplicate records

Write integration tests that exercise the service through its HTTP surface against a containerized dependency

Profile one endpoint and identify the single largest contributor to its response time

Model a realistic domain in both normalized (third normal form) and deliberately denormalized form, and state the read/write pattern that justifies each

Write and explain the execution plan for five queries: one using a composite index, one causing a full scan, one with a join across three tables, one with pagination, and one with an aggregate

Implement optimistic concurrency control with a version column and demonstrate a conflicting update being rejected

Choose between relational, document, and key-value storage for three given access patterns and defend each choice in two sentences

Design a versioned REST API for one resource, specifying status codes, error envelope, pagination, filtering, and idempotency behavior

Write an OpenAPI description for that API and generate a client or mock server from it to prove the contract is complete

Implement one backward-compatible change and one breaking change, and describe the deprecation and migration path for the breaking one

Add authentication to the API and demonstrate a request failing with 401 and another succeeding with a valid token

Containerize the service from earlier weeks with a multi-stage build and run it alongside its database using local orchestration

Define infrastructure as code for the service, its database, and network boundaries, then destroy and recreate the environment from that definition alone

Implement role-based access control with at least three roles and verify each role against one allowed and one denied action

Store all secrets outside source control and prove the running service reads them from the environment or secret manager

Instrument the service with structured logs, request tracing, and at least three metrics covering latency, error rate, and saturation

Run a load test to find the throughput ceiling and record where latency degrades past the stated budget

Define service-level indicators and objectives for availability and latency, and build one alert that fires on objective burn rather than a raw threshold

Inject a dependency failure and verify the service degrades gracefully through timeout, retry with backoff, and circuit breaking

Build a CI pipeline that runs linting, unit tests, integration tests, and a build artifact on every change

Add a schema migration step to the pipeline with a rollback path and demonstrate a failed migration being reverted

Write a test plan covering unit, integration, contract, and end-to-end layers, naming what each layer catches that the others miss

Complete two timed practice sets weighted toward the heaviest domains and log every missed question with its root cause

Revisit the week-1 architecture decision record and revise it with what you now know