Vibe Coding with IBM Bob: Building a Full-Stack Oracle Recruiting App in 3 Hours

TL;DR: I built a production-ready recruiting application — React frontend, FastAPI backend, Oracle 23AI database, Docker — in under 3 hours. Solo. No spec. No mockups. Just conversation with an AI coding assistant called IBM Bob. This is an honest account of how it happened and what it actually means for the way we deliver.

The Starting Point: One Prompt, No Brief

I work across multiple recruiting teams and had been stitching together data from three different tools to get a coherent view of my pipeline. I wanted something centralized — a single place where I could track candidates, positions, applications, and interviews without toggling between systems.

So I opened IBM Bob and typed this:

“Act as a senior Solution Architect specialized in HR and Recruiting systems. I want to build a Recruiting App following the best practices of recruiting and the standard recruiting business process. Use SQLite or Oracle 23AI database.”

No ticket. No spec. No mockup. That single sentence kicked off a 3-hour session that turned a vague internal need into a deployable enterprise tool. What follows is what actually happened — the good, the surprising, and the parts worth knowing before you try this yourself.

How the Session Actually Unfolded

The stack Bob chose was enterprise-grade from the start: React 18 frontend, FastAPI backend, Oracle 23AI as the database, Redis for caching, Docker Compose for the infrastructure. Not a toy — something that could actually run in a consulting environment. I didn’t specify any of that. It inferred it from the prompt.

Phase 1 — Architecture Before Code (15 min)

Bob’s first response wasn’t code. It was an architectural proposal.

Before writing a single line, it laid out the complete system design: the stack (React 18, FastAPI, Oracle 23AI, Redis, Docker Compose), the core data model (four entities — Candidates, Positions, Applications, Interviews — with their relationships and key fields), and the project folder structure and module boundaries.

None of this was in the prompt. Bob inferred enterprise-grade choices from three words: “best practices” and “recruiting.” It made the Oracle 23AI call over SQLite on its own, judging it the right fit for a system that would need relational integrity, scalable querying, and production-grade data handling. That’s the first shift in your mental model: the AI doesn’t just write code to spec — it makes architectural decisions and can defend them.

Phase 2 — Core Build (30 min)

With the architecture confirmed, Bob generated the foundational codebase in a single pass.

Database schema: Oracle 23AI DDL for all four entities, with foreign key constraints, indexes, and proper field typing. Backend: a running FastAPI application with initial CRUD endpoints, Pydantic models, and Docker configuration. Frontend: React scaffolding with routing, core views, and API integration wired up.

At the end of 30 minutes, the application was running. Not a prototype — a functional, navigable app with real data flowing end to end. The consistency was immediate: naming conventions, error handling patterns, and response structures were uniform across every layer from the first commit.

Phase 3 — Feature Expansion by Example (45 min)

I said: “I need to be able to edit Positions, Applications, and Interviews.” No field list, no UI spec. Bob looked at the existing candidate edit pattern and replicated it across the three other entities — same state logic, same error handling, same UI structure. One request, four consistent implementations.

This is the core mechanic of vibe coding: show the AI one working pattern and say “do this for X, Y, Z.” The translation is automatic, and the consistency is better than what you’d get coordinating a team.

Phase 4 — CSV and Data Integrity (35 min)

Two quick requests. First: “I don’t see CSV export and import.” Bob checked whether the backend endpoints existed (they did), then wired up the frontend buttons, download logic, upload handling, error states, and success notifications. Done.

Second: I noticed the interview form used free text for candidate selection. My ask was roughly: “That field should be a dropdown linked to the actual candidate list.” Bob converted it to a controlled dropdown, added dynamic loading from the API, formatted each option with linked application and position data, and disabled the field during edits to prevent orphaned records. I didn’t specify any of those implementation details. It inferred the data integrity concern and addressed it completely.

Phase 5 — The Interview Form (60 min)

The most demanding phase. I shared a structured French interview template — 5 sections, 37 Oracle module options, 4 competency dimensions scored 0–10, bilingual labels — and said “implement this.”

Bob generated the complete form in a single pass. Proper validation, create vs. edit modes, full French label structure, all 37 module options mapped correctly. What stood out wasn’t the code generation — it was the cross-domain comprehension. Bob held React state logic, FastAPI conventions, Oracle module taxonomy, and French business terminology in context simultaneously. That’s not autocomplete. That’s a different category of tool.

Phase 6 — Documentation & Git (30 min)

Final ask: document it and push it. Bob produced a 434-line build and deployment guide, initialized the repo, generated a proper .gitignore, committed 114 files with a meaningful message, and pushed to GitHub. DevOps handled as fluently as the application code.

The Honest Comparison

The 2–3 week estimate isn’t inflated. In a consulting context, requirements gathering alone is typically 2–3 days. Add design reviews, development cycles, integration testing, and UAT rounds — you’re looking at weeks for what we delivered in an afternoon. The Oracle Recruiting Application is an internal tool. Speed and adaptability were the right tradeoff. For a regulated client engagement with contractual specs, the calculus is different.

What Was Delivered

A working recruiting application: dashboard with real-time KPIs, candidate grid with CSV import/export and CV parsing, position management with status and priority tracking, a 7-stage Kanban pipeline, and a structured interview module with 37 Oracle-specific competency options. All backed by 32 API endpoints on Oracle 23AI, 114 files under version control, 11,600+ lines of code, and a Docker Compose stack that starts in 30 seconds.

5 Things That Actually Surprised Me

1. Vague prompts work — but precise context matters more. The opening prompt was intentionally loose. What made the session productive wasn’t precision in the ask — it was precision in the feedback loop. When something wasn’t right, I described the gap clearly. The AI handled the translation to code.

2. Cross-domain fluency is the real differentiator. IBM Bob held React, FastAPI, Oracle SQL, Docker, and French business terminology in context at the same time. That simultaneous fluency across domains is what separates modern AI coding assistants from search and autocomplete.

3. Consistency is free. When I asked for edit functionality across three entities, Bob applied the identical pattern — same state logic, same error handling, same UI structure — without being told to. In a team, that requires style guides, code reviews, and coordination. With AI, it just happens.

4. You still need to own the judgment calls. I let Bob handle syntax, API design, and database queries. I personally validated business logic, data integrity rules, and anything with security implications. That division isn’t optional — it’s what makes the output trustworthy.

5. The productivity claim is real, but bounded. Three hours for an internal tool on a stack I understand. That number doesn’t transfer to a regulated client environment, a legacy integration, or a system requiring formal verification. Know the envelope before you sell it.

Conclusion

Three hours. One developer. One AI. A production-ready recruiting application on Oracle 23AI, deployed via Docker, documented, and pushed to GitHub.

Vibe coding isn’t a shortcut — it’s a different mode of working. Requirements emerge through conversation. Iteration is immediate. Documentation is generated. The consultant’s job shifts from writing code to directing outcomes and validating what comes back.

For Oracle Cloud practitioners, the implication is clear: the skills that will matter aren’t deep familiarity with syntax. They’re the ability to frame problems precisely, validate AI output rigorously, and understand enough architecture to know when the AI is wrong. That’s a different kind of expertise — and it’s worth building now.

Appendix: Development Timeline

Resources: Oracle 23AI Free · FastAPI · React · GitHub Repository

Christian Guidibi
Oracle Cloud Practice Lead · AI & Enterprise Technology Consultant

Christian leads Oracle Cloud implementations and AI-assisted delivery in a consulting context. He writes about the intersection of enterprise architecture, modern AI tooling, and practical delivery at guidibi.com.