Home | Alpha FMC

Available courses

Test

Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since 1966, when designers at Letraset and James Mosley, the librarian at St Bride Printing Library in London, took a 1914 Cicero translation and scrambled it to make dummy text for Letraset's Body Type sheets. It has survived not only many decades, but also the leap into electronic typesetting, remaining essentially unchanged. It was popularised thanks to these sheets and more recently with desktop publishing software like Aldus PageMaker and Microsoft Word including versions of Lorem Ipsum.

Teacher: Vince Corradetti

Module 4 - Bedrock / AWS

Covers: foundation models on AWS Bedrock and Azure AI Foundry via SDK/CLI and Terraform (not console); multi-agent systems; Knowledge Bases / AI Search for RAG; content filters, quotas and cost.

Module 3 - Claude / Anthropic

Covers: the Messages API; prompt engineering; tool use; structured output; streaming; agentic patterns; MCP; integrating Claude into a real tool.

Module 2 - LLM Understanding

Covers: how LLMs generate text; tokens, context windows, temperature; prompting; embeddings & RAG; building and evaluating LLM apps.

Module 1 - Basic ML

Covers: supervised/unsupervised learning; regression & classification; over/underfitting; the scikit-learn workflow; evaluation.

Module 0 - Python (foundation) (optional - skip if you know Python)

Covers: core Python; data types & control flow; functions; files & packaging - the base for everything below.

Optional prerequisite. Quick gate: if you can write a function, use a list/dict comprehension, and load a file, skip to Module 1. Otherwise start here.

Track: Vue

Prerequisite: the shared TypeScript foundation above (do it once - not repeated here). Covers: reactivity & SFCs; components & composables; routing & state (Pinia); best practices, testing & tooling.

Track: React

Prerequisite: the shared TypeScript foundation above (do it once - not repeated here). Covers: components & hooks; routing; state management; reusable component libraries; performance, accessibility & best practices.

Foundation: TypeScript (shared by React and Vue)

Foundation: JavaScript (shared · optional - skip if you know JS)

Covers: variables & scope; functions & closures; arrays/objects; ES6 modules; promises & async/await; the DOM.

TypeScript (and the Node.js track in the BackEnd domain) assume these fundamentals. Anyone arriving from another language (Java, C#, Python, low-code) should do this first. Quick gate: if you can read a .map()/.filter() chain and an async/await call and know what they do, skip straight to the TypeScript track; otherwise start here.

Module 6 - Testing, Auth & Production

Covers: unit & integration testing (xUnit, Moq); authentication & authorisation (JWT, ASP.NET Core, an open-source web development framework | .NET Identity); logging & health checks; containerising with Docker; deployment & CI; microservice patterns.

Timeline: Staffed: 10 days. Unstaffed: 5 days.

Module 5 - Data with EF Core

Covers: DbContext & entities; migrations; relationships & loading strategies; LINQ-to-Entities; transactions; performance & tracking; the repository/unit-of-work debate.

Timeline: Staffed: 2 days. Unstaffed: 1 day.

Module 4: Core: Building APIs

ASP.NET Core, an open-source web development framework | .NET

Covers: minimal APIs & controllers; routing & model binding; dependency injection; middleware pipeline; validation; configuration & options; OpenAPI/Swagger.

Timeline: Staffed: 4 days. Unstaffed: 2 days.

Module 3 - Advanced C#

Covers: generics; delegates, events & lambdas; LINQ; async/await & the Task model; nullable reference types; records & pattern matching; spans & performance basics.

Timeline: Staffed: 4 days. Unstaffed: 2 days.

Module 2 - OOP & Interfaces

Covers: classes & objects; encapsulation, inheritance, polymorphism; interfaces & abstract classes; composition; SOLID basics.

Timeline: Staffed: 5 days. Unstaffed: 3 days.

Module 1 - C# Fundamentals

Covers: syntax & types; control flow; methods; value vs. reference types; arrays & collections; exceptions; the .NET runtime, SDK & project structure.

Timeline: Staffed: 5 days. Unstaffed: 3 days.

Module 6 - Deployment, Observability & Scale

Covers: Docker & Compose; environment config & graceful shutdown; background jobs (Celery/RQ) & caching (Redis); logging & metrics; CI; deploy to a managed platform.

Timeline: 1 month staffed, 2 weeks on bench

Module 5 - Production APIs & Async Data

Covers: routers + DI structure; async SQLAlchemy / SQLModel; migrations; global error handling; middleware (logging, CORS, rate limiting); settings management; integration tests.

Timeline: 1 month staffed, 2 weeks on bench

Module 4 - FastAPI: Building APIs

Covers: routing & path/query params; Pydantic v2 models; request/response validation; OAuth2 + JWT auth; dependency injection; auto OpenAPI docs; testing with httpx.

Timeline: 1 month staffed, 2 weeks on bench

Module 3 - Clean Architecture, Testing & Patterns

Covers: SOLID in Python; dependency injection; design patterns; pytest (fixtures, mocking, coverage); mypy; project structure & packaging.

Timeline: 1 month staffed, 2 weeks on bench

Module 2 - Idiomatic & Advanced Python

Covers: the data model & dunder methods; iterators, generators & context managers; decorators & closures; typing in depth; concurrency vs. parallelism; the standard library.

Module 1 - Core Python

Covers: syntax & types; control flow; functions; collections (list/dict/set/tuple); comprehensions; files & exceptions; modules, pip & virtual environments.
Timeline: ~6 months staffed, 4 months on bench

Module 1: NodeJS

Prerequisite: TypeScript (see the TypeScript track in the FrontEnd domain). Covers: runtime fundamentals; REST APIs with Express; databases & data layer; auth, security & testing; production & scale.

Timeline: Staffed: 17 weeks. Unstaffed: 3 weeks.

Module 0: Get Started

Start here: register for Appian's free online training and complete the Appian Developer course (~45 hours) - this is the core of Module 1. Then work through further courses in the Learn Builder catalog. Instructor Led courses are not offered at the moment

Modules: Appian foundations · Appian intermediate · Appian advanced

Certification note: Appian exams pause July 1 to September 1, 2026 (vendor migration to Meazure Learning).

Module 3 - Appian Advanced

Covers: application architecture and design patterns; data modelling at scale; performance tuning; DevOps/deployment; governance, security and platform administration.

Module 2 - Appian Intermediate

Covers: advanced SAIL and reusable components; record/related actions; query rules and performance; REST integrations and connected systems; robust process design.

Module 1 - Appian Foundations

Covers: platform and Designer; applications, groups and folders; records and data; interfaces with SAIL; expression rules; process models; basic integrations.

Module 5 - Databricks

Covers: Lakehouse architecture and Delta Lake; workspace, clusters and Unity Catalog; PySpark; Delta Live Tables; ETL pipeline design. Note: confirm real client demand before funding certification - only Snowflake referenced in current project notes.

Module 4 - Snowflake

Covers: architecture and warehouses; loading data; Streams/Tasks and Snowpipe; semi-structured data; performance and cost; Time Travel.

Module 3 - NoSQL (MongoDB and DynamoDB)

Covers: document vs. key-value stores and when NoSQL beats relational; MongoDB (documents, CRUD, aggregation pipeline, indexing, data modelling); AWS DynamoDB (partition/sort keys, single-table design, capacity and cost).

Module 2 - SQL

Covers: SELECT/filtering/aggregates; joins, subqueries and CTEs; window functions; query performance basics.

Module 1 - Data Architecture Foundations

Covers: relational vs. dimensional modelling (star and snowflake schemas); OLTP vs. OLAP; data warehouse vs. lake vs. lakehouse; ETL vs. ELT; batch vs. streaming; the medallion (bronze/silver/gold) pattern; data governance and quality basics.

Module 0 - Core Python and pandas (optional)

Optional prerequisite. Covers: core Python (via the Backend / Enterprise path); pandas for loading, cleaning, and transforming tabular data; NumPy basics.

Terraform Module 4 - Governance and Security

IAM least-privilege / Azure RBAC; Organizations + SCPs / Management Groups + Policy; CloudTrail / Azure Monitor; Secrets Manager / Key Vault via Terraform; Config / Azure Policy drift; NSGs in code. Certification: HashiCorp Terraform Associate (~$70.50, proctored). Capstone: a secure, multi-environment deployment via Terraform only.

Terraform Module 3 - Data Services and Migration

Provision RDS / Azure SQL via Terraform; read replicas, multi-AZ, backups; AWS DMS / Azure DMS migrations; VPC/VNet peering; connection pooling; S3 / Blob data-lake patterns.

Terraform Module 2 - Advanced Terraform

Reusable modules; workspaces and tfvars for multi-env; remote state with S3+DynamoDB or Azure Storage; state locking; GitHub Actions integration; terragrunt; validate, tflint, checkov.

Containers

Covers: Docker images and Compose; Kubernetes (Pods, Deployments, Services, ConfigMaps, ingress, Helm, RBAC); scaling and troubleshooting. Certification: Certified Kubernetes Administrator (CKA) ($445, proctored). Capstone: a containerized app on Kubernetes.