AI-Assisted Fullstack Engineering Program
Intensive 1-month program to identify and grow junior developers with potential, with an AI-first mindset and a single system that evolves end to end.
Central axis: Webhook Processing System
Technical Interview (30 min)
No live coding. A conversation to assess theoretical foundations and reasoning ability before the challenge.
Topics to evaluate
HTTP & APIs
- What is an endpoint?
- Difference between GET and POST
- HTTP status codes
Async & basic backend
- What does it mean for something to be asynchronous?
- What problem do queues solve?
Data modeling
- How would you model a payment event?
- What fields would be essential?
General thinking
- How they structure solutions and clarity when explaining
Pass criteria
- Good communication
- Correct fundamentals (even if not perfect)
- Evident capacity for learning
Live Vibe Coding Challenge
Evaluates how the candidate builds in real time, uses AI tools, and makes technical decisions.
Webhook Processing System
- Receive events via webhook
- Store them
- Display them in a web dashboard in real time
Backend — Webhook receiver
- Validate the payload
- Handle basic errors
- Respond quickly
Key requirements
- End-to-end working system
- Events persisted (even if only in memory)
- Code that is understandable (even if not perfect)
API contracts and mandatory frontend
POST /webhooks/payment{ "event_id": "evt_123", "event": "payment.completed", "amount": 250, "user_id": "123", "timestamp": 1710000000 }
Response{ "status": "received" }
GET /events[ { "event_id": "evt_123", "event": "payment.completed", "amount": 250, "user_id": "123" } ]
Frontend (mandatory)
- Simple page with an events table
fetchto/events- Auto-refresh every 2–5 s; must reflect new events without manual reload
Mandatory questions and evaluation
Architecture
- How would you prevent the same webhook from being processed twice?
- What would happen if 1,000 requests per second arrive?
- Where would you store events in production?
Code
- Why did you structure the code this way?
- What would you do differently with more time?
AI usage
- Which parts did you build with AI?
- How did you validate that the generated code is correct?
Strong signals
- Uses AI actively but understands the code
- Separates logic into layers
- Delivers a complete, working system
Weak signals
- Copies without understanding
- Does not integrate backend + frontend
- Does not implement auto-refresh
Bootcamp Core — Backend
Everything builds on what was delivered in Phase 1. Goal: transform the prototype into a real backend (Laravel).
Topics
- Laravel structure (controllers / services)
- Formal validation, migrations, ORM (Eloquent)
- Error handling and logging
System extension
- Database persistence
- Idempotency: validation by
event_id, unique constraint - Correct HTTP responses and structured logging of incoming events
Deliverable: a robust backend ready for basic production.
Full Application Build
Both paths implement exactly the same features; only the frontend stack differs.
Path A — Vue + Nuxt
Component-based, frontend state management, optional SSR. Skills: state management, API integration, componentization.
Path B — Blade + Turbo
Server-driven UI, HTML over JSON, Turbo. Skills: SSR, minimal JS, efficient UX.
Backend (both paths)
- Full events CRUD
- Authentication: login / logout and protected routes
- Pagination (limit and page navigation)
- Advanced filters: type, date range,
user_id
Frontend (both paths)
- Dashboard, paginated table, dynamic filters
- Create/edit forms and state management
- Smart auto-refresh that does not break pagination or filters
Architecture & Scaling
Make the system scalable and resilient: queues, workers, retries, rate limits, and observability.
- Queues and workers; retry logic
- Rate limiting and structured logging
- Webhook enqueues only — no inline processing
- Worker processes events; duplicates handled in the worker
Result: a decoupled system ready to handle real production load.
Specialization
Continues on the same system. Each track adds new features and technical depth based on role.
Track 1 — Fullstack
Product: metrics, real time, data export, and performance.
Track 2 — DevOps
Production: containers, CI/CD, environments, and observability.
Track 3 — QA
Quality: PHPUnit + Playwright, E2E, and edge cases.
The following slides document each track in detail.
Track 1 — Fullstack Developer
Goal: build advanced product features on top of the same Webhook Processing System.
1. Metrics system
- Total events
- Events by type
- Events by day
2. Real-time notifications
- WebSockets or optimised polling
- Live dashboard updates when new events arrive
3. Data export
- CSV export
- Active filters applied to the export
4. Optimisation
- Database indexing and query improvements
- Reduced perceived latency
Expected result
- Application usable by real users, good performance, and coherent UX
Track 2 — DevOps Engineer
Goal: take the system to real production with full automation and scalability.
1. Full Dockerization
- Containers for backend, database, and worker
2. CI/CD
- Automated build
- Automated tests in the pipeline
- Automated deploy to defined environments
3. Environments
- dev, staging, and production clearly separated
4. Observability
- Centralised logs
- Basic service metrics
- Health checks for orchestration and alerting
5. Operational scalability
- Multiple workers and load handling strategy
Expected result
- A deployable, fully automated, and scalable system
Track 3 — QA Engineer
Goal: guarantee the quality of the complete system with automation and critical thinking.
Stack
- PHPUnit (backend)
- Playwright (E2E in browser)
1. Backend testing
- Unit tests
- Integration tests (API, persistence, business rules)
2. E2E with Playwright — required cases
- Create, edit, and delete event
- Filter events and navigate pagination
- Login and logout
3. Edge cases
- Duplicate webhook
- High concurrency (simulated)
- Database or service failures
4. Quality report
- Test coverage
- Bugs found and severity
- Improvement recommendations
Program principles
- Single evolving system: everything on the same codebase
- AI as a core skill: effective use of AI is required
- Progressive complexity: prototype → app → scale → specialization
- Continuous evaluation: autonomy, velocity, and quality
Final result
A developer capable of building real systems quickly, using AI with judgment, understanding modern architecture, and scaling applications that start simple.
Suggested next steps (replicable program): scoring per phase, base repository, and standard AI prompts.
Process overview
Metrics
Infra
Testing