Prompt Details
Model
Chat - (gpt-5.6)
Token size
9,109
Example input
[English]: English
Example output
PROMPTFORGE — FREELANCER WORKSPACE WEB APP
ROLE
Act as a senior product architect, UX/UI designer, SaaS systems architect, security engineer, and full-stack technical lead.
You are responsible for transforming the product requirements below into a production-grade web application plan and implementation. Make professional technical and design decisions where the requirements do not specify an exact implementation, but do not invent user-specific business requirements.
Prioritize usability, architectural soundness, security, maintainability, accessibility, and implementation realism over unnecessary feature complexity.
---
PRIMARY OBJECTIVE
Design and prepare a modern SaaS freelancer workspace that helps growing freelancers manage:
- clients
- projects
- milestones
- tasks
- deadlines
- workload
- time tracking
- billable/non-billable hours
- invoices
- recurring invoices
- payment status
- files
- reminders
- reports
- project communication
- client communication
The result must be detailed enough to function as both:
1. a professional product blueprint for designers/developers, and
2. an authoritative specification that a coding AI can use to implement the application.
The product should remain focused on freelancer operations in V1 while using an architecture that can support broader business-management capabilities in future versions.
---
PRODUCT DIRECTION
Build a desktop-first web application with a mobile companion experience.
Desktop
Optimize for complex freelancer workflows:
- dashboard
- project management
- milestone planning
- task management
- Kanban
- calendar
- workload planning
- time tracking
- invoicing
- reports
- file management
- client management
- communication
- settings
Mobile
Optimize for quick actions rather than reproducing every desktop workflow:
- task/status updates
- deadline checking
- calendar
- timer controls
- notifications
- reminders
- quick client/project access
- lightweight communication
- invoice/status visibility where appropriate
The responsive strategy should be deliberate rather than simply shrinking the desktop UI onto smaller screens.
---
PRIMARY USERS
Freelancer
The primary user manages their own:
- clients
- projects
- milestones
- tasks
- time
- workload
- invoices
- files
- communications
- deadlines
- reports
Small-Team-Ready Architecture
V1 should primarily serve an individual freelancer while the underlying architecture accommodates adding collaborators later.
Design the data model and authorization boundaries so future team members can be introduced without requiring a fundamental rewrite.
Do not unnecessarily turn V1 into a full enterprise collaboration platform.
Client
Clients receive access through a dedicated client portal.
Clients should be able to:
- view relevant projects
- view milestones/deadlines
- view relevant files
- view invoices
- see invoice/payment status
- communicate with the freelancer
- participate in appropriate project communication
Client access must be isolated from the freelancer's private workspace and controlled through explicit permissions.
---
PRODUCT PRINCIPLES
Design the application around these principles:
1. Clarity over feature density
2. Fast access to important work
3. Strong information hierarchy
4. Minimal cognitive overhead
5. Professional SaaS quality
6. Consistent interaction patterns
7. Secure handling of client and financial information
8. Accessible by default
9. Reusable architecture
10. Future extensibility without premature complexity
The experience should feel like a polished professional productivity product rather than an accounting application or generic project-management clone.
---
CORE INFORMATION ARCHITECTURE
Design the product around an appropriate hierarchy such as:
Workspace → Client → Project → Milestone → Task
Relevant entities should also connect to:
- time entries
- files
- comments
- messages
- invoices
- payments/payment records
- reminders
- notifications
- reports
Define the relationships explicitly.
Avoid duplicated sources of truth.
---
CORE FEATURES
1. Dashboard
Create a useful operational dashboard showing information such as:
- current projects
- project status
- upcoming deadlines
- milestone deadlines
- overdue work
- task priorities
- workload
- tracked time
- billable hours
- outstanding invoices
- overdue invoices
- upcoming recurring invoices
- recent client activity
- notifications/reminders
The dashboard should help answer:
What requires my attention right now?
Do not overload it with low-value metrics.
---
2. Client Management
Provide a structured client area containing relevant:
- client profile
- contact information
- associated projects
- invoices
- payment status
- files
- communications
- activity history
- notes where appropriate
Separate private freelancer information from information exposed through the client portal.
---
3. Project Management
Projects should support:
- project name
- client
- description
- status
- start date
- target/end date
- budget or financial information where appropriate
- milestones
- tasks
- files
- time entries
- comments
- client communication
- related invoices
- activity history
Define sensible project states and transitions.
---
4. Milestones
Projects must support milestones.
Milestones should allow:
- name
- description
- status
- target date
- associated tasks
- progress
- relevant files
- comments
- client visibility where appropriate
Tasks should be associable with milestones.
Milestone deadlines must influence relevant dashboard, calendar, reminder, and workload views.
---
5. Task Management
Support:
- task title
- description
- project
- milestone
- status
- priority
- assignee architecture
- due date
- estimated effort
- tracked time
- billable status where relevant
- comments
- attachments/files
- activity history
Provide a Kanban view with sensible workflow states.
Also provide appropriate list/detail views.
Define useful empty, loading, error, overdue, completed, and archived states.
---
6. Calendar
Provide a unified calendar experience for relevant:
- task deadlines
- milestone deadlines
- project dates
- reminders
- other supported scheduling information
Make important deadline conflicts and overdue items easy to identify.
The calendar should complement, not replace, project/task management.
---
7. Workload Management
Help freelancers understand their upcoming workload.
Use relevant signals such as:
- upcoming due dates
- estimated task effort
- assigned work
- active projects
- tracked time
- overdue work
Do not create artificial productivity metrics without a meaningful purpose.
If the available information is insufficient for accurate capacity calculations, make the limitation explicit rather than presenting false precision.
---
8. Time Tracking
Implement advanced time tracking supporting:
- start/stop timer
- manual time entries
- editing entries
- project association
- task association
- billable/non-billable classification
- hourly rates
- notes
- date/time information
- activity summaries
Where appropriate, calculate:
- billable hours
- non-billable hours
- billable value
- invoiceable time
Design the data model so time entries remain auditable.
Avoid claiming that automatically tracked time is inherently accurate if the system cannot verify it.
---
9. Invoicing
Implement professional invoicing functionality supporting:
- invoice creation
- invoice numbering
- client association
- project association where appropriate
- line items
- quantities
- rates
- taxes
- discounts
- payment terms
- due dates
- notes
- invoice status
- recurring invoices
- invoice reminders
- PDF generation
- payment records/status
- overdue tracking
Define a clear invoice lifecycle.
For example, distinguish appropriately between states such as:
- draft
- issued/sent
- viewed where supported
- partially paid
- paid
- overdue
- cancelled/void
Do not assume that every payment provider or integration will expose identical payment states.
---
10. Payment Architecture
V1 should be payment-integration-ready rather than provider-dependent.
Define:
- payment-related domain entities
- payment status model
- transaction references
- webhook/event boundaries
- idempotency requirements
- reconciliation boundaries
- provider abstraction
- security considerations
Do not hard-code the architecture around one payment provider unless there is a strong technical reason.
Actual payment-provider implementation may remain optional.
Never store sensitive payment credentials or card data unnecessarily.
---
11. Recurring Invoices
Support recurring billing logic including:
- recurrence schedule
- start/end conditions
- next invoice date
- invoice template/data
- client association
- project association where relevant
- active/paused/cancelled states
- generation rules
- reminder behavior
Clearly distinguish a recurring-invoice definition from the individual invoices it generates.
---
12. Files
Provide file management associated with relevant:
- clients
- projects
- milestones
- tasks
- messages
Define:
- upload behavior
- metadata
- access permissions
- file visibility
- validation
- size/type restrictions
- storage abstraction
- deletion behavior
- authorization checks
Do not expose private freelancer files through the client portal by default.
---
13. Communication
Implement two complementary communication systems.
Contextual collaboration
Provide comments associated with relevant:
- projects
- milestones
- tasks
- files
Client messaging
Provide dedicated client conversation threads.
Support appropriate:
- messages
- timestamps
- read/unread state
- attachments
- notifications
- conversation permissions
- project/client association
Keep private internal comments separate from client-visible communication.
---
14. Notifications and Reminders
Support useful notifications around:
- approaching deadlines
- overdue tasks
- milestone deadlines
- invoice due dates
- overdue invoices
- client messages
- relevant project activity
- recurring invoice events
Avoid notification spam.
Design notification preferences and delivery architecture so additional channels can be introduced later.
---
15. Reports
Provide useful operational and financial reporting.
Potential reports include:
- billable vs non-billable time
- project time
- client time
- invoice status
- outstanding receivables
- revenue/invoiced totals where supported by the data
- project performance
- workload summaries
Do not present accounting-grade conclusions unless the underlying data and scope genuinely support them.
Clearly distinguish operational reporting from formal accounting.
---
AUTHENTICATION AND ACCESS
Use modern SaaS authentication supporting:
- email/password
- social login
- email verification
- password reset
- secure session management
- optional two-factor authentication
Design authorization separately from authentication.
Use role/permission boundaries that support:
- freelancer/owner
- future collaborators
- client users
Even if the initial UI exposes only a limited role set, the underlying authorization model should be extensible.
---
SECURITY, PRIVACY, AND AUDITABILITY
Treat client, project, communication, and financial information as sensitive business data.
Explicitly design for:
- secure authentication
- authorization on every protected resource
- tenant/workspace isolation
- least-privilege access
- secure session handling
- password security
- appropriate encryption in transit
- secure secret management
- input validation
- output encoding
- protection against common web vulnerabilities
- file-upload security
- API authorization
- rate limiting where appropriate
- audit logging for important actions
- safe error handling
- secure payment integration boundaries
- privacy-conscious data handling
- data deletion/export considerations
- backup/recovery considerations
Do not claim formal regulatory compliance unless the requirements and implementation actually establish it.
Identify where legal/privacy requirements depend on deployment jurisdiction and should be reviewed by qualified professionals.
---
ACCESSIBILITY
Design toward WCAG 2.2 AA-level accessibility where practical.
Specify:
- keyboard navigation
- visible focus states
- semantic structure
- accessible forms
- labels and validation messages
- sufficient contrast
- screen-reader considerations
- non-color-only status indicators
- accessible dialogs
- accessible tables and charts
- reduced-motion considerations
- responsive text/layout behavior
Accessibility must be part of the component architecture rather than an afterthought.
---
VISUAL DIRECTION
Use a modern SaaS visual language combining:
- efficient information architecture
- productivity-oriented layouts
- polished visual hierarchy
- premium but restrained presentation
- professional dashboards
- clear data visualization
- consistent spacing
- strong typography
- reusable components
- purposeful interaction feedback
Avoid:
- excessive decoration
- visual clutter
- gimmicky animations
- generic template aesthetics
- unnecessary gradients
- excessive glassmorphism
- poor information density
- dashboard elements that exist merely for appearance
Create a coherent design system covering:
- typography
- spacing
- layout
- grid
- colors
- surfaces
- borders
- shadows
- icons
- buttons
- forms
- tables
- cards
- navigation
- modals
- dropdowns
- tabs
- badges
- alerts
- toasts
- charts
- Kanban components
- calendar components
- responsive behavior
- interaction states
Include hover, focus, active, disabled, loading, empty, success, warning, error, and destructive states where relevant.
---
RESPONSIVE STRATEGY
Do not treat mobile as a smaller desktop.
Define which workflows are:
Desktop-primary
Examples:
- complex project setup
- advanced invoice editing
- reports
- workload planning
- detailed file management
- complex Kanban operations
Mobile-primary or mobile-optimized
Examples:
- checking deadlines
- starting/stopping timers
- updating task status
- reading/responding to messages
- reviewing notifications
- quick project access
Explain responsive behavior for important screens.
---
TECHNICAL ARCHITECTURE
You must recommend a modern, practical technology stack based on the requirements.
Do not select technologies merely because they are fashionable.
Evaluate the trade-offs of the chosen stack in terms of:
- development speed
- maintainability
- scalability
- security
- ecosystem maturity
- AI-assisted development
- hosting/deployment practicality
- developer availability
- database requirements
- authentication
- file storage
- background jobs
- notifications
- PDF generation
- future integrations
Prefer a coherent architecture over a collection of unrelated technologies.
Define, as appropriate:
- frontend architecture
- backend architecture
- database
- authentication
- API architecture
- file storage
- background jobs
- email/notification infrastructure
- PDF generation
- observability
- testing
- deployment
- environment management
- secrets/configuration
Where multiple technologies are viable, choose one recommended approach and briefly explain the rationale.
Do not present an endless list of alternatives.
---
DATA MODEL
Create a production-oriented conceptual data model.
Define relevant entities such as:
- Workspace
- User
- Membership
- Client
- ClientUser
- Project
- Milestone
- Task
- TimeEntry
- Invoice
- InvoiceItem
- RecurringInvoice
- Payment
- File
- Comment
- Conversation
- Message
- Notification
- Reminder
- AuditLog
Add or remove entities when justified by the actual architecture.
For each important entity specify:
- purpose
- key fields
- relationships
- ownership
- authorization considerations
- important indexes/constraints
- lifecycle/state considerations
Do not over-engineer the schema.
---
API AND BACKEND REQUIREMENTS
Define the API contract or equivalent server-side interfaces needed to support the application.
For important resources specify:
- endpoint/action
- HTTP method where applicable
- authentication requirement
- authorization requirement
- request structure
- validation
- response structure
- error behavior
- pagination/filtering/sorting where applicable
- idempotency requirements where relevant
Pay particular attention to:
- invoice operations
- recurring invoices
- payment events
- file operations
- client access
- messaging
- time tracking
- notifications
- audit logs
Use consistent API conventions.
---
VALIDATION AND ERROR HANDLING
Specify validation rules for important user inputs.
The application must handle:
- invalid input
- missing required fields
- invalid dates
- impossible date relationships
- duplicate records
- unauthorized access
- expired sessions
- unavailable resources
- upload failures
- payment integration failures
- email failures
- background-job failures
- network failures
- concurrency conflicts where relevant
Error messages should be understandable to users without exposing sensitive implementation details.
---
INTEGRATION ARCHITECTURE
Implement only essential integrations initially, while creating clean abstraction boundaries for future services.
The architecture should be capable of supporting future integrations involving:
- payment providers
- accounting systems
- calendars
- cloud storage
- email
- automation platforms
- other business tools
Do not build unnecessary integrations simply to make the specification look comprehensive.
---
SEARCH, FILTERING, AND PRODUCTIVITY
Where appropriate, provide efficient:
- search
- filtering
- sorting
- status filtering
- date filtering
- client/project filtering
- invoice filtering
- task filtering
Prioritize common workflows over exhaustive filtering everywhere.
---
PERFORMANCE
Define practical performance expectations for:
- dashboard loading
- project views
- Kanban interactions
- calendar views
- invoice lists
- messaging
- file operations
- mobile usage
Use pagination, lazy loading, caching, background processing, and other mechanisms where justified.
Do not optimize prematurely.
---
TWO-PHASE WORKFLOW
The work must happen in two explicit phases.
PHASE 1 — SPECIFICATION AND VALIDATION
Before implementation, produce a complete product and technical specification covering:
1. product overview
2. user roles
3. information architecture
4. user journeys
5. screen inventory
6. navigation
7. UX flows
8. functional requirements
9. design system
10. responsive behavior
11. data model
12. authorization model
13. API architecture
14. validation rules
15. error states
16. integrations
17. security/privacy
18. accessibility
19. performance considerations
20. testing strategy
21. deployment architecture
22. acceptance criteria
23. implementation plan
24. unresolved assumptions or risks
Then internally validate the specification for:
- contradictions
- missing dependencies
- impossible workflows
- inconsistent permissions
- duplicated data
- security gaps
- accessibility gaps
- mobile inconsistencies
- API/data-model mismatches
- unclear acceptance criteria
Resolve issues before moving to Phase 2.
If a genuinely critical product decision cannot be determined from the requirements, explicitly identify it rather than silently inventing a business rule.
PHASE 2 — IMPLEMENTATION
Use the validated Phase 1 specification as the authoritative implementation blueprint.
Implement the application according to that specification.
Do not casually redesign core architecture during implementation.
If implementation reveals a genuine technical conflict, identify the conflict, choose the smallest sound architectural adjustment, and keep the specification and implementation synchronized.
Build reusable components and maintainable modules rather than duplicating logic.
---
SCREEN AND UX SPECIFICATION
For every major screen, specify:
- purpose
- primary user
- entry points
- navigation
- layout
- major components
- primary actions
- secondary actions
- information hierarchy
- states
- permissions
- responsive behavior
- accessibility considerations
- relevant API/data dependencies
At minimum consider:
- login
- registration
- verification
- password reset
- dashboard
- clients
- client detail
- projects
- project detail
- milestone management
- task list
- Kanban
- task detail
- calendar
- workload
- time tracking
- invoices
- invoice creation/editing
- invoice detail
- recurring invoices
- reports
- files
- client messaging
- notifications
- settings
- profile/account
- client portal
- client project view
- client invoices
- client files
- client communication
Add screens when required by the architecture.
---
USER JOURNEYS
Define the critical end-to-end workflows, including:
New freelancer setup
Account → workspace → client → project → milestone → tasks
Project execution
Project → milestone → task → time tracking → completion
Client collaboration
Client portal → project → files/messages/comments → freelancer response
Invoice workflow
Project/time → invoice → send → reminder → payment status
Recurring billing
Recurring invoice definition → scheduled generation → invoice → reminder → payment record
Deadline management
Task/milestone → calendar → reminder → completion/overdue handling
Identify failure and recovery states for these workflows.
---
ACCEPTANCE CRITERIA
Create testable acceptance criteria for major functionality.
Criteria should describe observable behavior rather than vague quality claims.
Examples of the type of specificity required:
- A freelancer can create a project and associate it with an existing client.
- A project can contain milestones.
- A milestone can contain tasks and a target date.
- A time entry can be classified as billable or non-billable.
- Invoice totals correctly account for applicable line items, discounts, and taxes according to the defined calculation rules.
- A client cannot access another client's project data.
- Private freelancer comments cannot appear in the client portal.
- Unauthorized API requests are rejected.
- Important invoice/payment actions produce appropriate audit records.
Create the complete criteria yourself based on the final architecture.
---
TESTING STRATEGY
Define appropriate:
- unit tests
- integration tests
- API tests
- authorization tests
- end-to-end tests
- responsive tests
- accessibility tests
- critical financial calculation tests
- file/security tests
- payment-event tests
- regression tests
Prioritize testing around high-risk business logic and security boundaries.
---
FUTURE EXTENSIBILITY
Architect V1 so future features can be added without destabilizing the core system.
Potential future capabilities may include:
- additional team members
- advanced CRM
- proposals
- contracts
- expenses
- accounting integrations
- broader payment functionality
- automation
- advanced analytics
Do not implement these merely because they are possible.
Instead, identify architectural boundaries that make them feasible later.
---
IMPORTANT CONSTRAINTS
Do not:
- invent unprovided business policies as facts
- claim formal legal/regulatory compliance without evidence
- expose private client/workspace data
- hard-code the architecture unnecessarily to one future provider
- add features solely to increase perceived sophistication
- create artificial complexity
- sacrifice usability for technical novelty
- treat mobile as a scaled-down desktop
- mix private freelancer communication with client-visible communication
- treat operational reporting as formal accounting
- store unnecessary sensitive payment information
- hide critical assumptions
- leave important permission boundaries undefined
When a decision is genuinely unspecified but has low impact, make the most sensible professional choice.
When a decision is high-impact and cannot responsibly be inferred, explicitly flag it.
---
OUTPUT REQUIREMENTS
Phase 1 Deliverable
Produce a structured Product + Technical Specification containing:
1. Executive product definition
2. Product goals and non-goals
3. User roles and permissions
4. Information architecture
5. Feature architecture
6. User journeys
7. Complete screen inventory
8. Detailed screen specifications
9. Design system
10. Responsive strategy
11. Data model
12. API architecture
13. Authentication/authorization
14. Security/privacy architecture
15. Accessibility requirements
16. Integration architecture
17. Notification/reminder architecture
18. Validation/error strategy
19. Performance strategy
20. Testing strategy
21. Deployment architecture
22. Acceptance criteria
23. Implementation roadmap
24. Assumptions, risks, and unresolved decisions
Use tables where they improve clarity.
Do not bury important requirements inside long prose.
Phase 2 Deliverable
Implement the application using the validated specification.
The implementation must include:
- reusable components
- consistent styling
- functional navigation
- realistic application states
- appropriate responsive behavior
- authentication architecture
- authorization boundaries
- persistent data architecture
- core freelancer workflows
- client portal workflows
- project/milestone/task management
- Kanban
- calendar
- advanced time tracking
- professional invoicing
- recurring invoice architecture
- file management
- messaging/comments
- notifications/reminders
- reporting
- security protections
- accessibility considerations
- appropriate tests
If the environment prevents implementation of a particular infrastructure dependency, create a clean abstraction/mock boundary rather than pretending the dependency is fully operational.
---
QUALITY BAR
Do not consider the work complete merely because the screens look polished.
The finished result must be:
- functionally coherent
- technically implementable
- internally consistent
- secure by design
- accessible
- responsive
- maintainable
- extensible
- realistic for a modern SaaS product
- appropriate for growing freelancers
- useful for both freelancer and client workflows
- explicit about important assumptions
- testable through concrete acceptance criteria
The UI should feel like a credible modern SaaS product that a professional freelancer could realistically use every day.
---
SELF-CHECK
Before delivering each phase, silently verify:
1. Does the product clearly solve the stated freelancer-management problem?
2. Are freelancers and clients given the correct capabilities?
3. Are private and client-visible data properly separated?
4. Are projects correctly connected to milestones and tasks?
5. Are deadlines represented consistently across tasks, milestones, calendar, reminders, and dashboard?
6. Does time tracking correctly distinguish billable and non-billable work?
7. Are invoice calculations and lifecycle states clearly defined?
8. Are recurring invoices modeled separately from generated invoices?
9. Is payment integration provider-independent where appropriate?
10. Are authentication and authorization distinct and correctly designed?
11. Is the architecture ready for future collaborators?
12. Are files securely permissioned?
13. Are comments and client messaging appropriately separated?
14. Are important financial and security actions auditable?
15. Are mobile workflows intentionally designed rather than merely compressed?
16. Are accessibility requirements represented throughout the UI architecture?
17. Are API, database, and frontend requirements mutually consistent?
18. Are failure, loading, empty, overdue, and permission-denied states covered?
19. Have unsupported claims and invented facts been avoided?
20. Can another capable developer or coding AI understand and implement the specification without knowing this conversation?
Fix meaningful problems before presenting the deliverable.
---
COMPLETION CONDITION
Phase 1 is complete only when the specification is internally coherent, sufficiently detailed for implementation, and validated against the requirements above.
Phase 2 is complete only when the application implementation faithfully follows the validated specification and the critical user journeys, security boundaries, responsive behavior, and acceptance criteria have been addressed.
Do not declare success based solely on visual polish.
Deliver a production-grade freelancer workspace whose validated specification can serve as the authoritative blueprint for implementation, followed by an implementation that faithfully executes that blueprint.
Get this prompt + 9 more with Select$14 your first month, then $19/mo$14 first month, then $19/mo
View SelectBy purchasing this prompt, you agree to our terms of service
GPT-5.6
Turn any idea into a deeply structured, high-quality AI prompt through intelligent gap analysis, adaptive questioning, expert refinement, edge-case detection, and final self-review. Designed for beginners and advanced users, it adapts to the complexity of each task and helps transform incomplete ideas into clear, reusable prompts for writing, business, research, coding, marketing, education, and more.
...more
Added over 1 month ago
