Skip to content
DiaGO

Integrated System Design

The capstone - requirements to objects to UML to database to APIs to architecture, unified in one system-design document.

advanced6-8 hours

What you will produce

  • Requirements summary
  • Object model
  • Class diagram
  • Database schema
  • API specification
  • Architecture outline
  • System-design document
Open in Studio (class diagramwith this project's brief)Class diagram · the steps stay beside your canvas

Every project so far isolated one skill: modeling objects, drawing a diagram, normalizing a schema. Real design work is never that clean. A client hands you a paragraph of ambition, and you have to produce a document that a development team can actually build from — where the class diagram, the database, and the API all describe the same system without contradicting each other.

That is this capstone. You will choose one of two briefs and carry it through the entire pipeline: requirements -> object model -> class diagram -> database -> API -> architecture -> one unified system-design document.

Brief A: DeskHubBrief B: GatePass
DomainCo-working space: rooms, memberships, bookings, billingEvent ticketing: events, ticket tiers, purchases, check-in
Core ruleA booking must not overlap another booking for the same roomA tier must never sell more tickets than its capacity
MoneyMonthly membership plans plus overage chargesOne-off purchases with per-tier pricing

Both are deliberately sized to be completable. Every step below applies to either brief; examples alternate between them.

Before you start

You should have completed the core track first, especially objects and classes, class diagrams, ER modeling, REST resource design, and layered architecture.

Open DiaGO Studio's class editor for Step 3. Everything else happens in a text editor or on paper — keep one working file per step so Step 8 becomes assembly, not archaeology.

Step 1: Define the requirements

Write 10-15 numbered functional requirements and 3-5 quality requirements. Do this in text, not Studio. Scope ruthlessly: if a feature does not affect the domain model, the schema, or the API, cut it. Password reset, admin theming, and email templates are real work but teach you nothing here.

FR-1  A member can book an available room for a time slot.
FR-2  The system rejects a booking that overlaps an existing booking for the same room.
FR-3  A member's plan determines the booking hours included per month.
...
QR-1  Booking confirmation completes within 2 seconds at 100 concurrent users.
QR-2  No booking data is lost if the application server crashes.

Number everything. Those IDs are your tracing keys in Step 8.

Step 2: Create the object model

Reuse the noun-analysis technique from the course-management project: underline the nouns in your requirements, collect candidates, then prune duplicates, attributes-in-disguise, and things outside your scope. For each surviving object, assign responsibilities using Information Expert — the object that holds the data does the work on it.

Work on paper or in text (CRC cards work well). A partially filled example for GatePass:

ObjectKnowsDoes
Eventname, venue, schedule, its ticket tiersreports whether sales are open
TicketTierprice, capacity, tickets solddecides if a requested quantity is still available
Purchasebuyer, line items, timestampcomputes its own total

Fill in the rest — expect 6-10 objects. If an object only knows things and never does anything, ask whether a neighbor is doing its work for it.

Step 3: Create the class diagram in Studio

Translate the object model into a full class diagram in DiaGO Studio: attributes with types, visibility markers, operations, association names, and multiplicities at both ends — the complete notation from class diagrams.

Choose relationship strength deliberately. TicketTier has no meaning outside its Event, so composition fits; a Member and a Booking merely reference each other, so a plain association is enough. Use generalization only where behavior genuinely varies — plan types that compute overage differently qualify; two classes that happen to share three attributes do not.

Run Studio validation and fix everything it reports. A clean validation pass is a requirement of this project, not a suggestion — downstream steps assume the diagram is well-formed.

Step 4: Design the database

On paper or in text: list the entities that must survive a restart, sketch the ER diagram with cardinalities (see ER modeling), then write a relational schema in third normal form (see normalization).

The class model and the data model will not match one-to-one, and that is fine: inheritance flattens into columns or separate tables, and many-to-many associations become join tables. Record every such divergence — you will cite it in Step 8.

CREATE TABLE booking (
  id         BIGINT PRIMARY KEY,
  room_id    BIGINT NOT NULL REFERENCES room(id),
  member_id  BIGINT NOT NULL REFERENCES member(id),
  starts_at  TIMESTAMP NOT NULL,
  ends_at    TIMESTAMP NOT NULL,
  status     VARCHAR(16) NOT NULL
);

Note what the schema cannot enforce: FR-2's overlap rule needs application logic (or a database exclusion constraint) — a plain UNIQUE constraint only catches identical start times. Write that down as a decision.

Step 5: Define the APIs

Design the resource model per REST resource design: plural nouns, no verbs in paths, state changes via methods. Start with a resource table (text, partially filled for DeskHub):

ResourceURIMethodsBacking entities
Bookings/bookings, /bookings/idGET, POST, DELETEbooking, room, member
Rooms/rooms, /rooms/idGETroom

Then fully specify two endpoints — method, path, request, response, and at least one error case:

POST /bookings
{ "roomId": 42, "memberId": 7, "startsAt": "2026-07-14T09:00:00Z", "endsAt": "2026-07-14T11:00:00Z" }
201 Created
{ "id": 981, "roomId": 42, "memberId": 7, "status": "confirmed", "startsAt": "2026-07-14T09:00:00Z", "endsAt": "2026-07-14T11:00:00Z" }

Specify the 409 Conflict body for an overlapping booking yourself.

Step 6: Define services and architecture

Default to a single layered application: presentation -> application services -> domain -> persistence. Name your application services (BookingService, BillingService) and state which requirements each one owns.

If you split anything into a separate deployable service, justify it explicitly using the criteria from microservices trade-offs — at this scale, the honest answer is usually one process.

Reach for it

  • A part must scale or fail independently of the rest
  • A part is owned by a different team with its own release cadence
  • A part has genuinely different technology needs

Avoid it

  • The system fits comfortably in one process
  • You would split only to make the diagram look modern
  • The split would force distributed transactions across one workflow

Step 7: Outline the deployment

A short text outline is enough — no diagram required:

Browser SPA -> HTTPS -> app server (layered monolith, 2 replicas behind a load balancer)
App server  -> PostgreSQL (single primary, nightly backups)   [QR-2]
App server  -> payment provider (external; webhook callbacks)
Worker      -> reminder emails / check-in sync (async queue)

Annotate each line with the quality requirement it serves, as above.

Step 8: Assemble the system-design document

Combine everything into one document with this template:

1. Context            - the brief, in your own words (3-5 sentences)
2. Requirements       - Step 1, verbatim
3. Domain Model       - object table (Step 2) + exported class diagram (Step 3)
4. Data Design        - ER sketch + SQL schema (Step 4) + class-to-table divergences
5. API Contract       - resource table + two specified endpoints (Step 5)
6. Architecture       - layers and services (Step 6) + deployment outline (Step 7)
7. Decisions & Trade-offs - every "we chose X over Y because" collected along the way
8. Open Questions     - what you would ask the client next

Section 7 is where the document earns its keep: a reader should learn not just what you designed but what you rejected.

Check your work

This is the capstone rubric — every check crosses at least two artifacts:

  • Does every table in the schema correspond to a class in the diagram, with each deliberate divergence listed in Decisions and Trade-offs?
  • Does every API resource map to one or more entities in the schema, with no orphan endpoints?
  • Does every functional requirement trace to at least one artifact — a class, a table, or an endpoint? (Untraceable requirements mean the design is incomplete; untraceable classes mean scope creep.)
  • Do the field names and types in your two specified endpoints match the schema exactly?
  • Does Studio validation pass with zero errors and zero warnings?
  • Is every quality requirement addressed by a named architecture or deployment decision?
  • Is every composition and generalization in the diagram justified by lifecycle dependency or behavioral variation, not convenience?

Going further

  • Add invoicing (DeskHub) or refunds (GatePass) as a new capability, and argue — using the microservices trade-offs criteria — whether it belongs in the monolith or in a separate service.
  • Introduce the Observer pattern for booking or check-in notifications; update the class diagram and the Decisions section to match.
  • Design version 2 of one endpoint that changes its response shape without breaking existing clients, and document the migration path in Open Questions.