Skip to main content
Session management allows you to organize your interview preparation by creating separate sessions for each job application and resuming them at any time.

​
What is a session?

A session represents one complete interview preparation workflow for a specific job application. Each session contains:
  • Job title and company name
  • Your CV content
  • The job description
  • Complete interview conversation history
  • Generated feedback and performance analysis

​
Creating a session

To start a new interview preparation session:
1

Navigate to the homepage

Access the main dashboard where you can see all your previous sessions.
2

Enter job details

Provide two required pieces of information:
  • Job title - The position you’re applying for (e.g., “Senior Backend Engineer”)
  • Company name - The organization hiring for this role (e.g., “TechCorp Inc.”)
Job titles are limited to 200 characters. Both fields are required and cannot be empty.
3

Session created

The system creates a new session record and redirects you to the document upload page.

​
Validation rules

The session service enforces quality standards: 
class SessionService:
    def create_session(self, job_title: str, company_name: str) -> Session:
        if not job_title or not job_title.strip():
            raise ValidationError("Job title cannot be empty")
        
        if not company_name or not company_name.strip():
            raise ValidationError("Company name cannot be empty")
        
        if len(job_title) > 200:
            raise ValidationError(
                "Job title too long (max 200 characters)"
            )
        
        return self.session_repo.create(
            job_title=job_title.strip(), 
            company_name=company_name.strip()
        )

​
Session workflow

Each session progresses through distinct stages:

​
1. Created

Session exists with job details but no documents uploaded yet. What you can do:
  • Upload your CV
  • Paste the job description
  • Delete the session if created by mistake

​
2. Documents uploaded

Both CV and job description have been provided. What you can do:
  • Start the interview
  • View or update documents
  • Check if session is ready for interview
def is_ready_for_interview(self, session_id: int) -> bool:
    session = self.get_session(session_id)
    return bool(session.cv_text and session.job_description_text)

​
3. Interview in progress

At least one question has been asked and answered. What you can do:
  • Continue answering questions
  • View conversation history
  • Track progress (e.g., “3/8 questions”)
  • Resume later if needed

​
4. Interview completed

All 8 questions have been answered. What you can do:
  • Generate comprehensive feedback
  • Review complete conversation
  • View performance analysis

​
5. Feedback generated

AI analysis is complete with scores and suggestions. What you can do:
  • Review feedback report
  • Export as PDF
  • Start a new session for a different job
You can navigate back to any stage in a session. For example, view your conversation history even after feedback is generated.

​
Viewing sessions

The homepage displays all your sessions with key information:

​
Session list

Each session card shows:
  • Job title and company name
  • Creation date and time
  • Current status (e.g., “In progress”, “Completed”)
  • Quick action buttons

​
Filtering and organization

Sessions are ordered by:
  • Most recently created first
  • Easy identification of incomplete vs. completed sessions
  • Quick access to resume any session

​
Resuming a session

One of the most powerful features is the ability to resume incomplete sessions:

​
Automatic state preservation

The system automatically saves:
  • Your conversation history
  • Progress through the interview
  • Uploaded documents
  • All metadata about the session

​
Resume from any stage

You can return to a session and continue from:
  • Document upload (if not completed)
  • Middle of interview (if questions remain)
  • Feedback review (if already generated)
Once feedback is generated for a session, the interview is considered complete. You cannot add more answers to that session.

​
Session details

You can view comprehensive details for any session: 
def get_full_session_details(self, session_id: int) -> dict:
    session_with_messages = self.session_repo.get_session_with_messages(
        session_id
    )
    session_with_feedback = self.session_repo.get_session_with_feedback(
        session_id
    )
    
    return {
        "session": session_with_messages,
        "messages": session_with_messages.messages,
        "feedback": session_with_feedback.feedback if session_with_feedback else None,
    }
This provides:
  • Session metadata (job title, company, creation date)
  • All conversation messages with timestamps
  • Feedback data if generated
  • Complete audit trail of your preparation

​
Database structure

Sessions are stored with rich relational data: 
CREATE TABLE sessions (
    id INTEGER PRIMARY KEY,
    user_id INTEGER REFERENCES users(id),
    job_title VARCHAR(200) NOT NULL,
    company_name VARCHAR(200) NOT NULL,
    cv_text TEXT,
    job_description_text TEXT,
    created_at DATETIME DEFAULT CURRENT_TIMESTAMP
);

CREATE TABLE messages (
    id INTEGER PRIMARY KEY,
    session_id INTEGER NOT NULL REFERENCES sessions(id),
    role VARCHAR(20) NOT NULL,
    content TEXT NOT NULL,
    timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
);

CREATE TABLE feedback (
    id INTEGER PRIMARY KEY,
    session_id INTEGER NOT NULL REFERENCES sessions(id),
    interview_score INTEGER,
    strengths TEXT,
    weaknesses TEXT,
    cv_improvements TEXT,
    created_at DATETIME DEFAULT CURRENT_TIMESTAMP
);

​
Multiple sessions

You can create unlimited sessions to:

​
Prepare for different roles

Create separate sessions for:
  • Different positions at the same company
  • Same role at different companies
  • Various career paths you’re exploring

​
Track improvement

Compare feedback across sessions to:
  • See how your interview skills develop
  • Identify consistent strengths
  • Monitor progress on improvement areas
  • Refine your approach over time

​
Experiment with variations

Try different approaches:
  • Answer styles (concise vs. detailed)
  • Technical depth levels
  • Story selection and examples
  • CV presentation strategies

​
Session management operations

The platform provides essential session operations:

​
Retrieve session

def get_session(self, session_id: int) -> Session:
    session = self.session_repo.get_by_id(session_id)
    if not session:
        raise NotFoundError(f"Session {session_id} not found")
    return session

​
List all sessions

def get_all_sessions(self) -> list[Session]:
    return self.session_repo.get_all()

​
Delete session

def delete_session(self, session_id: int) -> None:
    self.session_repo.delete(session_id)
Deleting a session removes all associated data including conversation history and feedback. This action cannot be undone.

​
Retrieve multiple sessions

def get_sessions_by_ids(self, session_ids: list[int]) -> list[Session]:
    return self.session_repo.get_by_ids(session_ids)

​
Best practices

Create one session per job application. This allows you to:
  • Tailor your preparation to each specific role
  • Get targeted CV optimization suggestions
  • Track which applications you’ve prepared for
  • Maintain organized records of your job search
Not necessarily. The session system is designed for flexibility:
  • Start the interview when you have 15-20 minutes
  • Answer a few questions and return later
  • Complete at your own pace over multiple days
  • Your progress is automatically saved
Currently, job title and company name cannot be edited after session creation. If you made a mistake:
  • Delete the incorrect session
  • Create a new one with correct information
  • This ensures data integrity throughout the workflow
Sessions remain in the system indefinitely unless manually deleted. This allows you to:
  • Reference past interview preparations
  • Review feedback from previous applications
  • Track your improvement journey
  • Learn from patterns across multiple interviews
Session duplication is not currently supported. However, you can:
  • Create a new session with the same job title
  • Upload the same CV file
  • Use the same job description
  • Get fresh interview questions based on the same inputs
This gives you a new practice opportunity rather than repeating the same interview.

​
Session state tracking

The system maintains several flags to track session progress: 
{
    "has_cv": bool(session.cv_text),
    "has_job_description": bool(session.job_description_text),
    "is_ready_for_interview": bool(session.cv_text and session.job_description_text),
    "interview_started": question_count > 0,
    "interview_complete": question_count >= MAX_QUESTIONS,
    "has_feedback": feedback is not None
}
These flags power the UI to:
  • Show appropriate action buttons
  • Display correct page sections
  • Enable or disable features
  • Guide users through the workflow

​
API endpoints

Session management is handled through RESTful endpoints:
MethodEndpointPurpose
GET/List all sessions on homepage
POST/session/createCreate new session
GET/session/<id>/uploadView document upload page
GET/session/<id>/interviewAccess interview interface
GET/session/<id>/feedbackView feedback report
Each endpoint validates session existence and state before rendering the appropriate page.

Build docs developers (and LLMs) love

Get started for freeTalk to us