Back-End Development in Practice: Servers, APIs and Databases Behind the App
Signature Course No. 336 — A Signature AI Socratic Coaching Course.
Assumes you can already write code — your coach starts where you are.
A New Kind of Learning
Socratic coaching, delivered by an agentic AI coach.
Not a course you watch. An AI coach you work with.
The Lighthouse Coach begins by discovering how you think about the subject, teaches what is missing, and gives you realistic practice before asking you to prove that you can use it. You may test out of concepts you already understand, while capstones turn the learning into a practical plan, decision, conversation, or other real-world result.
The curriculum is deliberately authored; the AI delivers it through coaching. It is not an AI randomly generating lessons.
A coach that teaches by asking — not by lecturing
The Lighthouse Coach is an AI Socratic coach built on Cognosco Learning's Back-End Development in Practice: Servers, APIs and Databases Behind the App course, in the Personal Effectiveness & Well-Being category. It does not play videos at you. It holds a conversation: it asks you a question, listens to your answer, names the misconception it hears, affirms what you got right, and asks the next question — the way a great coach works in the room.
The server is where the business's rules live, because it is the only place they cannot be bypassed. Every app a user loves is two systems wearing one name, and the larger half runs where no user ever looks: a server that receives each request, decides who is asking and what they may do, reads and writes the data the business runs on, and refuses the requests that would corrupt that data. Prices are computed there, not trusted from the client. Permission is decided there, not inferred from which buttons the interface chose to draw. When that half is built badly, the failure is never cosmetic: a lost write is a lost order, and a missing permission check is a stranger reading someone's invoices.
It starts with the server's job. You will learn what a server actually does with a request from the moment it arrives to the moment the response leaves — one request, one response, no exceptions — and meet the running system in full: Pinnacle Pantry, a subscription box company whose service you will build on for the whole course, with its standing facts stated once and never quietly changed: 4,800 active subscriptions, 4,200 boxes in a typical week at $72, and 9,600 requests in the Monday peak hour.
It works in two movements. First, Module 1 — Build the Core Service: Requests, Data, and Persistence — Concepts 1–9: The Server's Job; The Running System; Routing and Handlers; The Data Model; Tables and Schema; Reading Data; Writing Data Safely; Validation at the Door; and Reading a Service Whole — finishing with The Working Core Service. Then, Module 2 — Secure, Scale, and Ship It: Identity, Reliability, and Operations — Concepts 10–18: Authentication in the Service; Authorization in Code; Secrets and Configuration; Concurrency and Duplicate Work; Caching and Performance; Background Jobs and External Calls; Testing the Service; Deploying and Running in Production; and The Builder's Standard — finishing with Ship It and Keep It Up.
Both capstones produce real artifacts — a complete build record for flex weeks, the new capability Pinnacle's subscribers ask for most: the three request stories traced before building, the extended data model, the schema migrations with every constraint's business sentence, the handlers with their validation, transactions, and duplicate defenses, and your own five-pass review; and a production dossier for Pantry at Work, the employer lunch-box launch that doubles the Monday peak — identity, permission, secrets, contention, jobs, tests, and the release itself, defended in writing.
The honesty standard is part of the course. The book builds on one coherent stack — a Node.js service written in TypeScript, with PostgreSQL as the database — as a teaching instrument, not a loyalty oath: every move transfers to another stack, and the concepts name the transferable move first. Where a fact is time-sensitive, the book marks it in the text rather than asserting it as permanent: today's recommended password-hashing functions, and framework-specific route-matching behavior, are both taught as things to verify. Every figure in the book is computed in the open from the running company's standing facts, where a pencil can check it.
The course is self-paced and always on — roughly 30 minutes per concept, about 9 hours in full, taken in as many sittings as you like. You can type your answers, or talk out loud: the Voice Coach speaks its questions and listens to your spoken replies. Learners who already know the material can test out concept by concept.
Back-End Development in Practice: Servers, APIs and Databases Behind the App is part of The Lighthouse Signature Series — the online counterpart to the one-day, in-person learning Cognosco Learning has delivered since 2002.
Course Facts
One full concept, coached end to end — free: verify your email and we’ll send you a link to start.
Already enrolled? Enter the course →
Diagnose → Learn & Practice → Prove → Capstone
Every learner moves through the same discipline a Cognosco instructor would insist on in the room.
Diagnose
The Coach starts where the course starts: with the server's job. Think of an app you use daily and name one thing its server must decide or compute that its interface could not be trusted to decide — and what goes wrong if the interface is trusted anyway; list everything that can happen next, from the user's side and the data's side, when a request never receives a response; and say which kinds of things legitimately vanish when a service restarts at midnight, which kind must never vanish, and where that second kind lives. Every concept opens with three questions that locate where you actually stand, and your answers shape how deeply the Coach works the concept with you. Everyone begins with Module 1 — no skipping the foundations you only think you have.
Learn & Practice
Work each concept in conversation with the Coach — spoken or written — then practice it against realistic situations until it holds up.
Prove
Every concept ends in proof: answer the check cold and demonstrate the skill. Know it already? Test out and take credit immediately.
Capstone
Finish with two capstones — The Working Core Service for Module 1 and Ship It and Keep It Up for Module 2 — that pull the whole course together, and earn the certificate.
What You'll Learn
Take the request apart; check everything; do the work; answer — in that order, every time. Every skill in this course is one of those four movements done honestly: a request arrives, it is routed, a handler runs, the handler reads or changes the data, and a response leaves. Every defect in a back end lives somewhere on that path, and this course teaches you to build the path station by station — and then to review it whole.
Module 1 builds the core service. What a server is for and the running system's standing facts; routing requests to handlers that do one job completely; the business's facts modeled as entities, relationships, and keys, then turned into a PostgreSQL schema that enforces the model; data read at a measured query cost and written inside transactions that leave nothing half-done; bad input refused at the door; and the build review that reads a whole service, seams first.
Module 2 secures, scales, and ships it. Who is calling, proved with passwords stored so a stolen database is not a stolen customer list; what they may do, checked in code on every request; secrets kept out of the code entirely; races and duplicate submissions absorbed by mechanism; time bought back with caching where the measurement says it belongs; slow work and outside calls moved into background jobs; a service tested at the levels where it can actually break; and a deployment — migrations included — that can be watched and rolled back.
And it holds the build side of the line throughout. The contract your service owes its consumers is taken as given here — designing that contract, and integrating against other people's, belongs to the library's API design course. This course goes deep on the back end alone, and stops where the browser begins: server, data model, persistence, authentication, and deployment of the service itself. It closes where it must — with the standard you sign when a business runs on the service you built.
What you will learn
- Trace a request through a server — routing, handlers, and the database — and build handlers that do one job completely
- Model a business's data as entities, relationships, and keys, and turn the model into a PostgreSQL schema that enforces it
- Read data with joins and measured query counts, and write data inside transactions that leave nothing half-done
- Validate every input in server code before it touches the data, and refuse bad work safely
- Implement authentication and authorization in the service — passwords stored properly, permission checked on every request
- Build for the bad day: duplicate submissions, races for the last item, slow partners, secrets kept out of code
- Test, deploy, observe, and roll back a production service, migrations included
Everything in the course
- All 18 concepts of Back-End Development in Practice: Servers, APIs and Databases Behind the App, in 2 modules
- A starting-point check first — the Coach finds where you actually stand before teaching
- Learn, Practice, Prove for every concept — no passive video watching
- A test-out on every concept: prove you know it and move on
- The Voice Coach: talk with the Coach out loud — it speaks, listens, and replies
- A personal Learner Record of your work across the course
- Two capstone exercises: The Working Core Service and Ship It and Keep It Up
- A printable session summary whenever you pause
- The Lighthouse Coach completion certificate (Signature Series)
- Your progress is saved as you go — stop anytime, resume where you left off
Built for the people who build the half of the app nobody sees
Developers and engineers — who are building, or about to build, server-side systems and need the whole craft in one disciplined pass, not framework syntax alone; and front-end developers moving toward the server who know what the browser sends and want to own what happens next.
Technical leads — who review other people's back-end work and need a build review that finds the seams before production does.
Founders and solo builders — whose one service is the business, and who cannot afford to learn transactions, password storage, or rollback from an incident. This course assumes you can write code in some language — read a function, follow a loop, reason about a short listing — and that you have at least seen an HTTP request and a database table before. It does not assume you have built a production service, designed a schema, or shipped anything.
Prefer to learn live and in person? The same material anchors Cognosco's one-day programs — browse the in-person catalog.
Start with The Server's Job
$195 — introductory price. One payment. No subscription, no password to manage.
Here is exactly what happens when you enroll:
- Pay securely with Stripe — you are taken straight into the course
- Create your learner profile and begin the Module 1 starting-point check
- Save the access key you are given — it restores your enrollment on any device
- Learn at your pace; your progress is stored in your browser on your device
For the full voice experience, use Chrome and allow the microphone when asked. Typing your answers works everywhere, all the time. Questions before you enroll? Email hello@cognoscolearning.com.
Before you enroll
What is a Socratic coaching session?
A conversation, not a video. Your coach asks a question; you answer — out loud by voice, or by typing — and the coach responds to what you said: naming the misconception it hears, affirming what you got right, and asking the next question. You advance only when you have mastered each concept, so a finished course means the learning held.
How long does it take — and how long do I have?
About 30 minutes per concept. Learn in sittings of any length; your progress is saved as you go. You have a full year from purchase to finish, and you can revisit and retake within that year.
What does the certificate verify?
That you completed every concept and both capstones of this course. Anyone can confirm a Cognosco certificate online — enter its certificate ID on our verification page.
What if it isn't for me — what are the refunds?
If you have not started, cancel for a full refund within seven days of purchase. Once you have started, there is no cash refund — stop before finishing and we credit the full amount you paid toward any other course in the library (credit valid one year from your original purchase). Once you complete the course, no refund or credit applies.
More Signature Courses are coming
Back-End Development in Practice: Servers, APIs and Databases Behind the App is Signature Course No. 336. Leave your email and we'll send you news of future Signature Courses and Lighthouse updates as they are announced — nothing else.